dmolinari/GestionIntegralWeb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Implementación de Secciones, Recargos, Porc. Pago Dist. y backend E/S Dist.

Browse Source 
Backend API:
- Recargos por Zona (`dist_RecargoZona`):
  - CRUD completo (Modelos, DTOs, Repositorio, Servicio, Controlador).
  - Endpoints anidados bajo `/publicaciones/{idPublicacion}/recargos`.
  - Lógica de negocio para vigencias (cierre/reapertura de períodos).
  - Auditoría en `dist_RecargoZona_H`.
- Porcentajes de Pago Distribuidores (`dist_PorcPago`):
  - CRUD completo (Modelos, DTOs, Repositorio, Servicio, Controlador).
  - Endpoints anidados bajo `/publicaciones/{idPublicacion}/porcentajespago`.
  - Lógica de negocio para vigencias.
  - Auditoría en `dist_PorcPago_H`.
- Porcentajes/Montos Pago Canillitas (`dist_PorcMonPagoCanilla`):
  - CRUD completo (Modelos, DTOs, Repositorio, Servicio, Controlador).
  - Endpoints anidados bajo `/publicaciones/{idPublicacion}/porcentajesmoncanilla`.
  - Lógica de negocio para vigencias.
  - Auditoría en `dist_PorcMonPagoCanilla_H`.
- Secciones de Publicación (`dist_dtPubliSecciones`):
  - CRUD completo (Modelos, DTOs, Repositorio, Servicio, Controlador).
  - Endpoints anidados bajo `/publicaciones/{idPublicacion}/secciones`.
  - Auditoría en `dist_dtPubliSecciones_H`.
- Entradas/Salidas Distribuidores (`dist_EntradasSalidas`):
  - Implementado backend (Modelos, DTOs, Repositorio, Servicio, Controlador).
  - Lógica para determinar precios/recargos/porcentajes aplicables.
  - Cálculo de monto y afectación de saldos de distribuidores en `cue_Saldos`.
  - Auditoría en `dist_EntradasSalidas_H`.
- Correcciones de Mapeo Dapper:
  - Aplicados alias explícitos en repositorios de RecargoZona, PorcPago, PorcMonCanilla, PubliSeccion,
    Canilla, Distribuidor y Precio para asegurar mapeo correcto de IDs y columnas.

Frontend React:
- Recargos por Zona:
  - `recargoZonaService.ts`.
  - `RecargoZonaFormModal.tsx` para crear/editar períodos de recargos.
  - `GestionarRecargosPublicacionPage.tsx` para listar y gestionar recargos por publicación.
- Porcentajes de Pago Distribuidores:
  - `porcPagoService.ts`.
  - `PorcPagoFormModal.tsx`.
  - `GestionarPorcentajesPagoPage.tsx`.
- Porcentajes/Montos Pago Canillitas:
  - `porcMonCanillaService.ts`.
  - `PorcMonCanillaFormModal.tsx`.
  - `GestionarPorcMonCanillaPage.tsx`.
- Secciones de Publicación:
  - `publiSeccionService.ts`.
  - `PubliSeccionFormModal.tsx`.
  - `GestionarSeccionesPublicacionPage.tsx`.
- Navegación:
  - Actualizadas rutas y menús para acceder a la gestión de recargos, porcentajes (dist. y canillita) y secciones desde la vista de una publicación.
- Layout:
  - Uso consistente de `Box` con Flexbox en lugar de `Grid` en nuevos modales y páginas para evitar errores de tipo.
This commit is contained in:
eldiadmolinari
2025-05-21 14:58:52 -03:00
parent b6ba52f074
commit e7e185a9cb
140 changed files with 10465 additions and 394 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/CanillaRepository.cs
View File

@@ -1,7 +1,7 @@
using Dapper;
using GestionIntegral.Api.Data.Repositories;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System; // Para Exception
using System.Collections.Generic;
using System.Data;
using System.Linq;
@@ -24,10 +24,14 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
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
SELECT
c.Id_Canilla AS IdCanilla, c.Legajo, c.NomApe, c.Parada, c.Id_Zona AS IdZona,
c.Accionista, c.Obs, c.Empresa, c.Baja, c.FechaBaja,
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
LEFT JOIN dbo.dist_dtEmpresas e ON c.Empresa = e.Id_Empresa
WHERE 1=1");
var parameters = new DynamicParameters();
@@ -37,13 +41,13 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
}
if (!string.IsNullOrWhiteSpace(nomApeFilter))
{
sqlBuilder.Append(" AND c.NomApe LIKE @NomApe");
parameters.Add("NomApe", $"%{nomApeFilter}%");
sqlBuilder.Append(" AND c.NomApe LIKE @NomApeParam");
parameters.Add("NomApeParam", $"%{nomApeFilter}%");
}
if (legajoFilter.HasValue)
{
sqlBuilder.Append(" AND c.Legajo = @Legajo");
parameters.Add("Legajo", legajoFilter.Value);
sqlBuilder.Append(" AND c.Legajo = @LegajoParam");
parameters.Add("LegajoParam", legajoFilter.Value);
}
sqlBuilder.Append(" ORDER BY c.NomApe;");
@@ -59,7 +63,7 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener todos los Canillas.");
_logger.LogError(ex, "Error al obtener todos los Canillas. Filtros: NomApe='{NomApeFilter}', Legajo='{LegajoFilter}', SoloActivos='{SoloActivos}'", nomApeFilter, legajoFilter, soloActivos);
return Enumerable.Empty<(Canilla, string, string)>();
}
}
@@ -67,18 +71,22 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
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
SELECT
c.Id_Canilla AS IdCanilla, c.Legajo, c.NomApe, c.Parada, c.Id_Zona AS IdZona,
c.Accionista, c.Obs, c.Empresa, c.Baja, c.FechaBaja,
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";
WHERE c.Id_Canilla = @IdParam";
try
{
using var connection = _connectionFactory.CreateConnection();
var result = await connection.QueryAsync<Canilla, string, string, (Canilla, string, string)>(
var result = await connection.QueryAsync<Canilla, string, string, (Canilla?, string?, string?)>(
sql,
(canilla, nombreZona, nombreEmpresa) => (canilla, nombreZona, nombreEmpresa),
new { Id = id },
new { IdParam = id },
splitOn: "NombreZona,NombreEmpresa"
);
return result.SingleOrDefault();
@@ -89,25 +97,37 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
return (null, null, null);
}
}
public async Task<Canilla?> GetByIdSimpleAsync(int id) // Para uso interno del servicio
public async Task<Canilla?> GetByIdSimpleAsync(int id)
{
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 });
const string sql = @"
SELECT
Id_Canilla AS IdCanilla, Legajo, NomApe, Parada, Id_Zona AS IdZona,
Accionista, Obs, Empresa, Baja, FechaBaja
FROM dbo.dist_dtCanillas
WHERE Id_Canilla = @IdParam";
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<Canilla>(sql, new { IdParam = id });
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener Canilla (simple) por ID: {IdCanilla}", id);
return null;
}
}
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
if (legajo == 0) return false;
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtCanillas WHERE Legajo = @LegajoParam AND Legajo != 0");
var parameters = new DynamicParameters();
parameters.Add("Legajo", legajo);
parameters.Add("LegajoParam", legajo);
if (excludeIdCanilla.HasValue)
{
sqlBuilder.Append(" AND Id_Canilla != @ExcludeIdCanilla");
parameters.Add("ExcludeIdCanilla", excludeIdCanilla.Value);
sqlBuilder.Append(" AND Id_Canilla != @ExcludeIdCanillaParam");
parameters.Add("ExcludeIdCanillaParam", excludeIdCanilla.Value);
}
try
{
@@ -125,23 +145,24 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
const string sqlInsert = @"
INSERT INTO dbo.dist_dtCanillas (Legajo, NomApe, Parada, Id_Zona, Accionista, Obs, Empresa, Baja, FechaBaja)
OUTPUT INSERTED.*
OUTPUT INSERTED.Id_Canilla AS IdCanilla, INSERTED.Legajo, INSERTED.NomApe, INSERTED.Parada, INSERTED.Id_Zona AS IdZona,
INSERTED.Accionista, INSERTED.Obs, INSERTED.Empresa, INSERTED.Baja, INSERTED.FechaBaja
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.");
if (insertedCanilla == null || insertedCanilla.IdCanilla == 0) throw new DataException("No se pudo crear el canillita o obtener su ID.");
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 (@IdCanillaParam, @LegajoParam, @NomApeParam, @ParadaParam, @IdZonaParam, @AccionistaParam, @ObsParam, @EmpresaParam, @BajaParam, @FechaBajaParam, @Id_UsuarioParam, @FechaModParam, @TipoModParam);";
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"
IdCanillaParam = insertedCanilla.IdCanilla, LegajoParam = insertedCanilla.Legajo, NomApeParam = insertedCanilla.NomApe, ParadaParam = insertedCanilla.Parada, IdZonaParam = insertedCanilla.IdZona,
AccionistaParam = insertedCanilla.Accionista, ObsParam = insertedCanilla.Obs, EmpresaParam = insertedCanilla.Empresa, BajaParam = insertedCanilla.Baja, FechaBajaParam = insertedCanilla.FechaBaja,
Id_UsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModParam = "Creado"
}, transaction);
return insertedCanilla;
}
@@ -150,27 +171,29 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
var connection = transaction.Connection!;
var canillaActual = await connection.QuerySingleOrDefaultAsync<Canilla>(
"SELECT * FROM dbo.dist_dtCanillas WHERE Id_Canilla = @IdCanilla", new { canillaAActualizar.IdCanilla }, transaction);
@"SELECT Id_Canilla AS IdCanilla, Legajo, NomApe, Parada, Id_Zona AS IdZona,
Accionista, Obs, Empresa, Baja, FechaBaja
FROM dbo.dist_dtCanillas WHERE Id_Canilla = @IdCanillaParam",
new { IdCanillaParam = 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);";
VALUES (@IdCanillaParam, @LegajoParam, @NomApeParam, @ParadaParam, @IdZonaParam, @AccionistaParam, @ObsParam, @EmpresaParam, @BajaParam, @FechaBajaParam, @Id_UsuarioParam, @FechaModParam, @TipoModParam);";
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"
IdCanillaParam = canillaActual.IdCanilla,
LegajoParam = canillaActual.Legajo, NomApeParam = canillaActual.NomApe, ParadaParam = canillaActual.Parada, IdZonaParam = canillaActual.IdZona,
AccionistaParam = canillaActual.Accionista, ObsParam = canillaActual.Obs, EmpresaParam = canillaActual.Empresa,
BajaParam = canillaActual.Baja, FechaBajaParam = canillaActual.FechaBaja,
Id_UsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModParam = "Actualizado"
}, transaction);
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, canillaAActualizar, transaction);
@@ -181,24 +204,27 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
var connection = transaction.Connection!;
var canillaActual = await connection.QuerySingleOrDefaultAsync<Canilla>(
"SELECT * FROM dbo.dist_dtCanillas WHERE Id_Canilla = @IdCanilla", new { IdCanilla = id }, transaction);
@"SELECT Id_Canilla AS IdCanilla, Legajo, NomApe, Parada, Id_Zona AS IdZona,
Accionista, Obs, Empresa, Baja, FechaBaja
FROM dbo.dist_dtCanillas WHERE Id_Canilla = @IdCanillaParam",
new { IdCanillaParam = 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 sqlUpdate = "UPDATE dbo.dist_dtCanillas SET Baja = @BajaParam, FechaBaja = @FechaBajaParam WHERE Id_Canilla = @IdCanillaParam;";
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);";
VALUES (@IdCanillaParam, @LegajoParam, @NomApeParam, @ParadaParam, @IdZonaParam, @AccionistaParam, @ObsParam, @EmpresaParam, @BajaNuevaParam, @FechaBajaNuevaParam, @Id_UsuarioParam, @FechaModParam, @TipoModHistParam);";
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")
IdCanillaParam = canillaActual.IdCanilla, LegajoParam = canillaActual.Legajo, NomApeParam = canillaActual.NomApe, ParadaParam = canillaActual.Parada, IdZonaParam = canillaActual.IdZona,
AccionistaParam = canillaActual.Accionista, ObsParam = canillaActual.Obs, EmpresaParam = canillaActual.Empresa,
BajaNuevaParam = darDeBaja, FechaBajaNuevaParam = (darDeBaja ? fechaBaja : null),
Id_UsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModHistParam = (darDeBaja ? "Baja" : "Alta")
}, transaction);
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, new { Baja = darDeBaja, FechaBaja = (darDeBaja ? fechaBaja : null), IdCanilla = id }, transaction);
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, new { BajaParam = darDeBaja, FechaBajaParam = (darDeBaja ? fechaBaja : null), IdCanillaParam = id }, transaction);
return rowsAffected == 1;
}
}

157
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/DistribuidorRepository.cs
View File

@@ -1,6 +1,7 @@
using Dapper;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System; // Añadido para Exception
using System.Collections.Generic;
using System.Data;
using System.Linq;
@@ -23,7 +24,10 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
public async Task<IEnumerable<(Distribuidor Distribuidor, string? NombreZona)>> GetAllAsync(string? nombreFilter, string? nroDocFilter)
{
var sqlBuilder = new StringBuilder(@"
SELECT d.*, z.Nombre AS NombreZona
SELECT
d.Id_Distribuidor AS IdDistribuidor, d.Nombre, d.Contacto, d.NroDoc, d.Id_Zona AS IdZona,
d.Calle, d.Numero, d.Piso, d.Depto, d.Telefono, d.Email, d.Localidad,
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");
@@ -31,13 +35,13 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
if (!string.IsNullOrWhiteSpace(nombreFilter))
{
sqlBuilder.Append(" AND d.Nombre LIKE @Nombre");
parameters.Add("Nombre", $"%{nombreFilter}%");
sqlBuilder.Append(" AND d.Nombre LIKE @NombreParam");
parameters.Add("NombreParam", $"%{nombreFilter}%");
}
if (!string.IsNullOrWhiteSpace(nroDocFilter))
{
sqlBuilder.Append(" AND d.NroDoc LIKE @NroDoc");
parameters.Add("NroDoc", $"%{nroDocFilter}%");
sqlBuilder.Append(" AND d.NroDoc LIKE @NroDocParam");
parameters.Add("NroDocParam", $"%{nroDocFilter}%");
}
sqlBuilder.Append(" ORDER BY d.Nombre;");
@@ -53,7 +57,7 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener todos los Distribuidores.");
_logger.LogError(ex, "Error al obtener todos los Distribuidores. Filtros: Nombre='{NombreFilter}', NroDoc='{NroDocFilter}'", nombreFilter, nroDocFilter);
return Enumerable.Empty<(Distribuidor, string?)>();
}
}
@@ -61,17 +65,20 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
public async Task<(Distribuidor? Distribuidor, string? NombreZona)> GetByIdAsync(int id)
{
const string sql = @"
SELECT d.*, z.Nombre AS NombreZona
SELECT
d.Id_Distribuidor AS IdDistribuidor, d.Nombre, d.Contacto, d.NroDoc, d.Id_Zona AS IdZona,
d.Calle, d.Numero, d.Piso, d.Depto, d.Telefono, d.Email, d.Localidad,
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";
WHERE d.Id_Distribuidor = @IdParam";
try
{
using var connection = _connectionFactory.CreateConnection();
var result = await connection.QueryAsync<Distribuidor, string, (Distribuidor, string?)>(
var result = await connection.QueryAsync<Distribuidor, string, (Distribuidor?, string?)>(
sql,
(dist, zona) => (dist, zona),
new { Id = id },
new { IdParam = id },
splitOn: "NombreZona"
);
return result.SingleOrDefault();
@@ -85,73 +92,112 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
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 });
const string sql = @"
SELECT
Id_Distribuidor AS IdDistribuidor, Nombre, Contacto, NroDoc, Id_Zona AS IdZona,
Calle, Numero, Piso, Depto, Telefono, Email, Localidad
FROM dbo.dist_dtDistribuidores
WHERE Id_Distribuidor = @IdParam";
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<Distribuidor>(sql, new { IdParam = id });
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener Distribuidor (simple) por ID: {IdDistribuidor}", id);
return null;
}
}
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 sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtDistribuidores WHERE NroDoc = @NroDocParam");
var parameters = new DynamicParameters();
parameters.Add("NroDoc", nroDoc);
parameters.Add("NroDocParam", nroDoc);
if (excludeIdDistribuidor.HasValue)
{
sqlBuilder.Append(" AND Id_Distribuidor != @ExcludeId");
parameters.Add("ExcludeId", excludeIdDistribuidor.Value);
sqlBuilder.Append(" AND Id_Distribuidor != @ExcludeIdParam");
parameters.Add("ExcludeIdParam", excludeIdDistribuidor.Value);
}
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error en ExistsByNroDocAsync. NroDoc: {NroDoc}", nroDoc);
return true;
}
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 sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtDistribuidores WHERE Nombre = @NombreParam");
var parameters = new DynamicParameters();
parameters.Add("Nombre", nombre);
parameters.Add("NombreParam", nombre);
if (excludeIdDistribuidor.HasValue)
{
sqlBuilder.Append(" AND Id_Distribuidor != @ExcludeId");
parameters.Add("ExcludeId", excludeIdDistribuidor.Value);
sqlBuilder.Append(" AND Id_Distribuidor != @ExcludeIdParam");
parameters.Add("ExcludeIdParam", excludeIdDistribuidor.Value);
}
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error en ExistsByNameAsync. Nombre: {Nombre}", nombre);
return true;
}
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"
"SELECT TOP 1 1 FROM dbo.dist_EntradasSalidas WHERE Id_Distribuidor = @IdParam",
"SELECT TOP 1 1 FROM dbo.cue_PagosDistribuidor WHERE Id_Distribuidor = @IdParam",
"SELECT TOP 1 1 FROM dbo.dist_PorcPago WHERE Id_Distribuidor = @IdParam"
};
foreach (var query in checkQueries)
try
{
if (await connection.ExecuteScalarAsync<int?>(query, new { Id = id }) == 1) return true;
foreach (var query in checkQueries)
{
if (await connection.ExecuteScalarAsync<int?>(query, new { IdParam = id }) == 1) return true;
}
return false;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error en IsInUseAsync para Distribuidor ID: {IdDistribuidor}", id);
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.*
OUTPUT INSERTED.Id_Distribuidor AS IdDistribuidor, INSERTED.Nombre, INSERTED.Contacto, INSERTED.NroDoc, INSERTED.Id_Zona AS IdZona,
INSERTED.Calle, INSERTED.Numero, INSERTED.Piso, INSERTED.Depto, INSERTED.Telefono, INSERTED.Email, INSERTED.Localidad
VALUES (@Nombre, @Contacto, @NroDoc, @IdZona, @Calle, @Numero, @Piso, @Depto, @Telefono, @Email, @Localidad);";
var connection = transaction.Connection!;
var inserted = await connection.QuerySingleAsync<Distribuidor>(sqlInsert, nuevoDistribuidor, transaction);
if (inserted == null || inserted.IdDistribuidor == 0) throw new DataException("Error al crear distribuidor o al obtener el ID generado.");
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.");
VALUES (@IdDistribuidorParam, @NombreParam, @ContactoParam, @NroDocParam, @IdZonaParam, @CalleParam, @NumeroParam, @PisoParam, @DeptoParam, @TelefonoParam, @EmailParam, @LocalidadParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
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"
IdDistribuidorParam = inserted.IdDistribuidor, NombreParam = inserted.Nombre, ContactoParam = inserted.Contacto, NroDocParam = inserted.NroDoc, IdZonaParam = inserted.IdZona,
CalleParam = inserted.Calle, NumeroParam = inserted.Numero, PisoParam = inserted.Piso, DeptoParam = inserted.Depto, TelefonoParam = inserted.Telefono, EmailParam = inserted.Email, LocalidadParam = inserted.Localidad,
IdUsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModParam = "Creado"
}, transaction);
return inserted;
}
@@ -160,8 +206,10 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
var connection = transaction.Connection!;
var actual = await connection.QuerySingleOrDefaultAsync<Distribuidor>(
"SELECT * FROM dbo.dist_dtDistribuidores WHERE Id_Distribuidor = @IdDistribuidor",
new { distribuidorAActualizar.IdDistribuidor }, transaction);
@"SELECT Id_Distribuidor AS IdDistribuidor, Nombre, Contacto, NroDoc, Id_Zona AS IdZona,
Calle, Numero, Piso, Depto, Telefono, Email, Localidad
FROM dbo.dist_dtDistribuidores WHERE Id_Distribuidor = @IdDistribuidorParam",
new { IdDistribuidorParam = distribuidorAActualizar.IdDistribuidor }, transaction);
if (actual == null) throw new KeyNotFoundException("Distribuidor no encontrado.");
const string sqlUpdate = @"
@@ -172,13 +220,13 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
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);";
VALUES (@IdDistribuidorParam, @NombreParam, @ContactoParam, @NroDocParam, @IdZonaParam, @CalleParam, @NumeroParam, @PisoParam, @DeptoParam, @TelefonoParam, @EmailParam, @LocalidadParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
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"
IdDistribuidorParam = actual.IdDistribuidor, NombreParam = actual.Nombre, ContactoParam = actual.Contacto, NroDocParam = actual.NroDoc, IdZonaParam = actual.IdZona,
CalleParam = actual.Calle, NumeroParam = actual.Numero, PisoParam = actual.Piso, DeptoParam = actual.Depto, TelefonoParam = actual.Telefono, EmailParam = actual.Email, LocalidadParam = actual.Localidad,
IdUsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModParam = "Actualizado"
}, transaction);
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, distribuidorAActualizar, transaction);
@@ -189,23 +237,26 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
var connection = transaction.Connection!;
var actual = await connection.QuerySingleOrDefaultAsync<Distribuidor>(
"SELECT * FROM dbo.dist_dtDistribuidores WHERE Id_Distribuidor = @Id", new { Id = id }, transaction);
@"SELECT Id_Distribuidor AS IdDistribuidor, Nombre, Contacto, NroDoc, Id_Zona AS IdZona,
Calle, Numero, Piso, Depto, Telefono, Email, Localidad
FROM dbo.dist_dtDistribuidores WHERE Id_Distribuidor = @IdParam", new { IdParam = id }, transaction);
if (actual == null) throw new KeyNotFoundException("Distribuidor no encontrado.");
const string sqlDelete = "DELETE FROM dbo.dist_dtDistribuidores WHERE Id_Distribuidor = @Id";
// ... (resto del método DeleteAsync)
const string sqlDelete = "DELETE FROM dbo.dist_dtDistribuidores WHERE Id_Distribuidor = @IdParam";
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);";
VALUES (@IdDistribuidorParam, @NombreParam, @ContactoParam, @NroDocParam, @IdZonaParam, @CalleParam, @NumeroParam, @PisoParam, @DeptoParam, @TelefonoParam, @EmailParam, @LocalidadParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
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"
IdDistribuidorParam = actual.IdDistribuidor, NombreParam = actual.Nombre, ContactoParam = actual.Contacto, NroDocParam = actual.NroDoc, IdZonaParam = actual.IdZona,
CalleParam = actual.Calle, NumeroParam = actual.Numero, PisoParam = actual.Piso, DeptoParam = actual.Depto, TelefonoParam = actual.Telefono, EmailParam = actual.Email, LocalidadParam = actual.Localidad,
IdUsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModParam = "Eliminado"
}, transaction);
var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { Id = id }, transaction);
var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { IdParam = id }, transaction);
return rowsAffected == 1;
}
}

180
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/EntradaSalidaDistRepository.cs Normal file
View File

@@ -0,0 +1,180 @@
using Dapper;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System;
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 EntradaSalidaDistRepository : IEntradaSalidaDistRepository
{
private readonly DbConnectionFactory _cf;
private readonly ILogger<EntradaSalidaDistRepository> _log;
public EntradaSalidaDistRepository(DbConnectionFactory cf, ILogger<EntradaSalidaDistRepository> log)
{
_cf = cf;
_log = log;
}
public async Task<IEnumerable<EntradaSalidaDist>> GetAllAsync(DateTime? fechaDesde, DateTime? fechaHasta, int? idPublicacion, int? idDistribuidor, string? tipoMovimiento)
{
var sqlBuilder = new StringBuilder(@"
SELECT
Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Distribuidor AS IdDistribuidor,
Fecha, TipoMovimiento, Cantidad, Remito, Observacion,
Id_Precio AS IdPrecio, Id_Recargo AS IdRecargo, Id_Porcentaje AS IdPorcentaje
FROM dbo.dist_EntradasSalidas
WHERE 1=1");
var parameters = new DynamicParameters();
if (fechaDesde.HasValue) { sqlBuilder.Append(" AND Fecha >= @FechaDesdeParam"); parameters.Add("FechaDesdeParam", fechaDesde.Value.Date); }
if (fechaHasta.HasValue) { sqlBuilder.Append(" AND Fecha <= @FechaHastaParam"); parameters.Add("FechaHastaParam", fechaHasta.Value.Date); }
if (idPublicacion.HasValue) { sqlBuilder.Append(" AND Id_Publicacion = @IdPublicacionParam"); parameters.Add("IdPublicacionParam", idPublicacion.Value); }
if (idDistribuidor.HasValue) { sqlBuilder.Append(" AND Id_Distribuidor = @IdDistribuidorParam"); parameters.Add("IdDistribuidorParam", idDistribuidor.Value); }
if (!string.IsNullOrWhiteSpace(tipoMovimiento)) { sqlBuilder.Append(" AND TipoMovimiento = @TipoMovimientoParam"); parameters.Add("TipoMovimientoParam", tipoMovimiento); }
sqlBuilder.Append(" ORDER BY Fecha DESC, Id_Parte DESC;");
try
{
using var connection = _cf.CreateConnection();
return await connection.QueryAsync<EntradaSalidaDist>(sqlBuilder.ToString(), parameters);
}
catch (Exception ex)
{
_log.LogError(ex, "Error al obtener Entradas/Salidas de Distribuidores.");
return Enumerable.Empty<EntradaSalidaDist>();
}
}
public async Task<EntradaSalidaDist?> GetByIdAsync(int idParte)
{
const string sql = @"
SELECT
Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Distribuidor AS IdDistribuidor,
Fecha, TipoMovimiento, Cantidad, Remito, Observacion,
Id_Precio AS IdPrecio, Id_Recargo AS IdRecargo, Id_Porcentaje AS IdPorcentaje
FROM dbo.dist_EntradasSalidas
WHERE Id_Parte = @IdParteParam";
try
{
using var connection = _cf.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<EntradaSalidaDist>(sql, new { IdParteParam = idParte });
}
catch (Exception ex)
{
_log.LogError(ex, "Error al obtener EntradaSalidaDist por ID: {IdParte}", idParte);
return null;
}
}
public async Task<bool> ExistsByRemitoAndTipoForPublicacionAsync(int remito, string tipoMovimiento, int idPublicacion, int? excludeIdParte = null)
{
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_EntradasSalidas WHERE Remito = @RemitoParam AND TipoMovimiento = @TipoMovimientoParam AND Id_Publicacion = @IdPublicacionParam");
var parameters = new DynamicParameters();
parameters.Add("RemitoParam", remito);
parameters.Add("TipoMovimientoParam", tipoMovimiento);
parameters.Add("IdPublicacionParam", idPublicacion);
if (excludeIdParte.HasValue)
{
sqlBuilder.Append(" AND Id_Parte != @ExcludeIdParteParam");
parameters.Add("ExcludeIdParteParam", excludeIdParte.Value);
}
try
{
using var connection = _cf.CreateConnection();
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
}
catch (Exception ex)
{
_log.LogError(ex, "Error en ExistsByRemitoAndTipoForPublicacionAsync. Remito: {Remito}", remito);
return true; // Asumir que existe en caso de error para prevenir duplicados
}
}
public async Task<EntradaSalidaDist?> CreateAsync(EntradaSalidaDist nuevaES, int idUsuario, IDbTransaction transaction)
{
const string sqlInsert = @"
INSERT INTO dbo.dist_EntradasSalidas (Id_Publicacion, Id_Distribuidor, Fecha, TipoMovimiento, Cantidad, Remito, Observacion, Id_Precio, Id_Recargo, Id_Porcentaje)
OUTPUT INSERTED.Id_Parte AS IdParte, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Id_Distribuidor AS IdDistribuidor,
INSERTED.Fecha, INSERTED.TipoMovimiento, INSERTED.Cantidad, INSERTED.Remito, INSERTED.Observacion,
INSERTED.Id_Precio AS IdPrecio, INSERTED.Id_Recargo AS IdRecargo, INSERTED.Id_Porcentaje AS IdPorcentaje
VALUES (@IdPublicacion, @IdDistribuidor, @Fecha, @TipoMovimiento, @Cantidad, @Remito, @Observacion, @IdPrecio, @IdRecargo, @IdPorcentaje);";
const string sqlHistorico = @"
INSERT INTO dbo.dist_EntradasSalidas_H
(Id_Parte, Id_Publicacion, Id_Distribuidor, Fecha, TipoMovimiento, Cantidad, Remito, Observacion, Id_Precio, Id_Recargo, Id_Porcentaje, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdParteHist, @IdPublicacionHist, @IdDistribuidorHist, @FechaHist, @TipoMovimientoHist, @CantidadHist, @RemitoHist, @ObservacionHist, @IdPrecioHist, @IdRecargoHist, @IdPorcentajeHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
var inserted = await transaction.Connection!.QuerySingleAsync<EntradaSalidaDist>(sqlInsert, nuevaES, transaction);
if (inserted == null || inserted.IdParte == 0) throw new DataException("Error al crear Entrada/Salida o ID no generado.");
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdParteHist = inserted.IdParte, IdPublicacionHist = inserted.IdPublicacion, IdDistribuidorHist = inserted.IdDistribuidor,
FechaHist = inserted.Fecha, TipoMovimientoHist = inserted.TipoMovimiento, CantidadHist = inserted.Cantidad, RemitoHist = inserted.Remito, ObservacionHist = inserted.Observacion,
IdPrecioHist = inserted.IdPrecio, IdRecargoHist = inserted.IdRecargo, IdPorcentajeHist = inserted.IdPorcentaje,
IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Creada"
}, transaction);
return inserted;
}
public async Task<bool> UpdateAsync(EntradaSalidaDist esAActualizar, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<EntradaSalidaDist>(
@"SELECT Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Distribuidor AS IdDistribuidor, Fecha, TipoMovimiento, Cantidad, Remito, Observacion, Id_Precio AS IdPrecio, Id_Recargo AS IdRecargo, Id_Porcentaje AS IdPorcentaje
FROM dbo.dist_EntradasSalidas WHERE Id_Parte = @IdParteParam",
new { IdParteParam = esAActualizar.IdParte }, transaction);
if (actual == null) throw new KeyNotFoundException("Registro de Entrada/Salida no encontrado.");
const string sqlUpdate = @"
UPDATE dbo.dist_EntradasSalidas SET
Cantidad = @Cantidad, Observacion = @Observacion
-- Publicacion, Distribuidor, Fecha, TipoMovimiento, Remito, Ids de precio/recargo/porc no se modifican aquí
WHERE Id_Parte = @IdParte;";
const string sqlHistorico = @"
INSERT INTO dbo.dist_EntradasSalidas_H
(Id_Parte, Id_Publicacion, Id_Distribuidor, Fecha, TipoMovimiento, Cantidad, Remito, Observacion, Id_Precio, Id_Recargo, Id_Porcentaje, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdParteHist, @IdPublicacionHist, @IdDistribuidorHist, @FechaHist, @TipoMovimientoHist, @CantidadHist, @RemitoHist, @ObservacionHist, @IdPrecioHist, @IdRecargoHist, @IdPorcentajeHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdParteHist = actual.IdParte, IdPublicacionHist = actual.IdPublicacion, IdDistribuidorHist = actual.IdDistribuidor,
FechaHist = actual.Fecha, TipoMovimientoHist = actual.TipoMovimiento, CantidadHist = actual.Cantidad, RemitoHist = actual.Remito, ObservacionHist = actual.Observacion,
IdPrecioHist = actual.IdPrecio, IdRecargoHist = actual.IdRecargo, IdPorcentajeHist = actual.IdPorcentaje, // Valores ANTERIORES
IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Actualizada"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlUpdate, esAActualizar, transaction);
return rowsAffected == 1;
}
public async Task<bool> DeleteAsync(int idParte, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<EntradaSalidaDist>(
@"SELECT Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Distribuidor AS IdDistribuidor, Fecha, TipoMovimiento, Cantidad, Remito, Observacion, Id_Precio AS IdPrecio, Id_Recargo AS IdRecargo, Id_Porcentaje AS IdPorcentaje
FROM dbo.dist_EntradasSalidas WHERE Id_Parte = @IdParteParam",
new { IdParteParam = idParte }, transaction);
if (actual == null) throw new KeyNotFoundException("Registro de Entrada/Salida no encontrado para eliminar.");
const string sqlDelete = "DELETE FROM dbo.dist_EntradasSalidas WHERE Id_Parte = @IdParteParam";
const string sqlHistorico = @"
INSERT INTO dbo.dist_EntradasSalidas_H
(Id_Parte, Id_Publicacion, Id_Distribuidor, Fecha, TipoMovimiento, Cantidad, Remito, Observacion, Id_Precio, Id_Recargo, Id_Porcentaje, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdParteHist, @IdPublicacionHist, @IdDistribuidorHist, @FechaHist, @TipoMovimientoHist, @CantidadHist, @RemitoHist, @ObservacionHist, @IdPrecioHist, @IdRecargoHist, @IdPorcentajeHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdParteHist = actual.IdParte, IdPublicacionHist = actual.IdPublicacion, IdDistribuidorHist = actual.IdDistribuidor,
FechaHist = actual.Fecha, TipoMovimientoHist = actual.TipoMovimiento, CantidadHist = actual.Cantidad, RemitoHist = actual.Remito, ObservacionHist = actual.Observacion,
IdPrecioHist = actual.IdPrecio, IdRecargoHist = actual.IdRecargo, IdPorcentajeHist = actual.IdPorcentaje,
IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Eliminada"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdParteParam = idParte }, transaction);
return rowsAffected == 1;
}
}
}

18
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/IEntradaSalidaDistRepository.cs Normal file
View File

@@ -0,0 +1,18 @@
using GestionIntegral.Api.Models.Distribucion;
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
public interface IEntradaSalidaDistRepository
{
Task<IEnumerable<EntradaSalidaDist>> GetAllAsync(DateTime? fechaDesde, DateTime? fechaHasta, int? idPublicacion, int? idDistribuidor, string? tipoMovimiento);
Task<EntradaSalidaDist?> GetByIdAsync(int idParte);
Task<EntradaSalidaDist?> CreateAsync(EntradaSalidaDist nuevaES, int idUsuario, IDbTransaction transaction);
Task<bool> UpdateAsync(EntradaSalidaDist esAActualizar, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteAsync(int idParte, int idUsuario, IDbTransaction transaction);
Task<bool> ExistsByRemitoAndTipoForPublicacionAsync(int remito, string tipoMovimiento, int idPublicacion, int? excludeIdParte = null);
}
}

18
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/IPorcMonCanillaRepository.cs
View File

@@ -1,10 +1,20 @@
using GestionIntegral.Api.Models.Distribucion;
using System;
using System.Collections.Generic;
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);
}
public interface IPorcMonCanillaRepository
{
Task<IEnumerable<(PorcMonCanilla Item, string NomApeCanilla)>> GetByPublicacionIdAsync(int idPublicacion);
Task<PorcMonCanilla?> GetByIdAsync(int idPorcMon);
Task<PorcMonCanilla?> GetActiveByPublicacionCanillaAndDateAsync(int idPublicacion, int idCanilla, DateTime fecha, IDbTransaction? transaction = null);
Task<PorcMonCanilla?> CreateAsync(PorcMonCanilla nuevoItem, int idUsuario, IDbTransaction transaction);
Task<bool> UpdateAsync(PorcMonCanilla itemAActualizar, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteAsync(int idPorcMon, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction);
Task<PorcMonCanilla?> GetPreviousActiveAsync(int idPublicacion, int idCanilla, DateTime vigenciaDNuevo, IDbTransaction transaction);
}
}

15
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/IPorcPagoRepository.cs
View File

@@ -1,9 +1,20 @@
using GestionIntegral.Api.Models.Distribucion;
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
public interface IPorcPagoRepository {
{
public interface IPorcPagoRepository
{
Task<IEnumerable<(PorcPago PorcPago, string NombreDistribuidor)>> GetByPublicacionIdAsync(int idPublicacion);
Task<PorcPago?> GetByIdAsync(int idPorcentaje);
Task<PorcPago?> GetActiveByPublicacionDistribuidorAndDateAsync(int idPublicacion, int idDistribuidor, DateTime fecha, IDbTransaction? transaction = null);
Task<PorcPago?> CreateAsync(PorcPago nuevoPorcPago, int idUsuario, IDbTransaction transaction);
Task<bool> UpdateAsync(PorcPago porcPagoAActualizar, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteAsync(int idPorcentaje, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction);
Task<PorcPago?> GetPreviousActivePorcPagoAsync(int idPublicacion, int idDistribuidor, DateTime vigenciaDNuevo, IDbTransaction transaction);
}
}

17
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/IPubliSeccionRepository.cs
View File

@@ -1,10 +1,19 @@
using GestionIntegral.Api.Models.Distribucion;
using System.Collections.Generic;
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);
}
public interface IPubliSeccionRepository
{
Task<IEnumerable<PubliSeccion>> GetByPublicacionIdAsync(int idPublicacion, bool? soloActivas = null);
Task<PubliSeccion?> GetByIdAsync(int idSeccion);
Task<PubliSeccion?> CreateAsync(PubliSeccion nuevaSeccion, int idUsuario, IDbTransaction transaction);
Task<bool> UpdateAsync(PubliSeccion seccionAActualizar, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteAsync(int idSeccion, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction); // Ya existe
Task<bool> ExistsByNameInPublicacionAsync(string nombre, int idPublicacion, int? excludeIdSeccion = null);
Task<bool> IsInUseAsync(int idSeccion); // Verificar en bob_RegPublicaciones, bob_StockBobinas
}
}

12
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/IRecargoZonaRepository.cs
View File

@@ -1,3 +1,6 @@
using GestionIntegral.Api.Models.Distribucion;
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;
@@ -5,6 +8,13 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
public interface IRecargoZonaRepository
{
Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction);
Task<IEnumerable<(RecargoZona Recargo, string NombreZona)>> GetByPublicacionIdAsync(int idPublicacion);
Task<RecargoZona?> GetByIdAsync(int idRecargo); // Para obtener un recargo específico
Task<RecargoZona?> GetActiveByPublicacionZonaAndDateAsync(int idPublicacion, int idZona, DateTime fecha, IDbTransaction? transaction = null);
Task<RecargoZona?> CreateAsync(RecargoZona nuevoRecargo, int idUsuario, IDbTransaction transaction);
Task<bool> UpdateAsync(RecargoZona recargoAActualizar, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteAsync(int idRecargo, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction); // Ya existe
Task<RecargoZona?> GetPreviousActiveRecargoAsync(int idPublicacion, int idZona, DateTime vigenciaDNuevo, IDbTransaction transaction);
}
}

17
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/ISalidaOtroDestinoRepository.cs Normal file
View File

@@ -0,0 +1,17 @@
using GestionIntegral.Api.Models.Distribucion;
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
public interface ISalidaOtroDestinoRepository
{
Task<IEnumerable<SalidaOtroDestino>> GetAllAsync(DateTime? fechaDesde, DateTime? fechaHasta, int? idPublicacion, int? idDestino);
Task<SalidaOtroDestino?> GetByIdAsync(int idParte);
Task<SalidaOtroDestino?> CreateAsync(SalidaOtroDestino nuevaSalida, int idUsuario, IDbTransaction transaction);
Task<bool> UpdateAsync(SalidaOtroDestino salidaAActualizar, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteAsync(int idParte, int idUsuario, IDbTransaction transaction);
}
}

247
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/PorcMonCanillaRepository.cs
View File

@@ -1,56 +1,255 @@
using Dapper;
using System.Data;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
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; }
private readonly DbConnectionFactory _cf;
private readonly ILogger<PorcMonCanillaRepository> _log;
public PorcMonCanillaRepository(DbConnectionFactory connectionFactory, ILogger<PorcMonCanillaRepository> logger)
{
_cf = connectionFactory;
_log = logger;
}
public async Task<IEnumerable<(PorcMonCanilla Item, string NomApeCanilla)>> GetByPublicacionIdAsync(int idPublicacion)
{
const string sql = @"
SELECT
pmc.Id_PorcMon AS IdPorcMon, pmc.Id_Publicacion AS IdPublicacion, pmc.Id_Canilla AS IdCanilla,
pmc.VigenciaD, pmc.VigenciaH, pmc.PorcMon, pmc.EsPorcentaje,
c.NomApe AS NomApeCanilla
FROM dbo.dist_PorcMonPagoCanilla pmc
INNER JOIN dbo.dist_dtCanillas c ON pmc.Id_Canilla = c.Id_Canilla
WHERE pmc.Id_Publicacion = @IdPublicacionParam
ORDER BY c.NomApe, pmc.VigenciaD DESC";
try
{
using var connection = _cf.CreateConnection();
return await connection.QueryAsync<PorcMonCanilla, string, (PorcMonCanilla, string)>(
sql,
(item, nomApe) => (item, nomApe),
new { IdPublicacionParam = idPublicacion },
splitOn: "NomApeCanilla"
);
}
catch (Exception ex)
{
_log.LogError(ex, "Error al obtener PorcMonCanilla por Publicacion ID: {IdPublicacion}", idPublicacion);
return Enumerable.Empty<(PorcMonCanilla, string)>();
}
}
public async Task<PorcMonCanilla?> GetByIdAsync(int idPorcMon)
{
const string sql = @"
SELECT
Id_PorcMon AS IdPorcMon, Id_Publicacion AS IdPublicacion, Id_Canilla AS IdCanilla,
VigenciaD, VigenciaH, PorcMon, EsPorcentaje
FROM dbo.dist_PorcMonPagoCanilla
WHERE Id_PorcMon = @IdPorcMonParam";
try
{
using var connection = _cf.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<PorcMonCanilla>(sql, new { IdPorcMonParam = idPorcMon });
}
catch (Exception ex)
{
_log.LogError(ex, "Error al obtener PorcMonCanilla por ID: {IdPorcMon}", idPorcMon);
return null;
}
}
public async Task<PorcMonCanilla?> GetActiveByPublicacionCanillaAndDateAsync(int idPublicacion, int idCanilla, DateTime fecha, IDbTransaction? transaction = null)
{
const string sql = @"
SELECT TOP 1
Id_PorcMon AS IdPorcMon, Id_Publicacion AS IdPublicacion, Id_Canilla AS IdCanilla,
VigenciaD, VigenciaH, PorcMon, EsPorcentaje
FROM dbo.dist_PorcMonPagoCanilla
WHERE Id_Publicacion = @IdPublicacionParam AND Id_Canilla = @IdCanillaParam
AND VigenciaD <= @FechaParam
AND (VigenciaH IS NULL OR VigenciaH >= @FechaParam)
ORDER BY VigenciaD DESC;";
var cn = transaction?.Connection ?? _cf.CreateConnection();
bool ownConnection = transaction == null;
PorcMonCanilla? result = null;
try
{
if (ownConnection && cn.State == ConnectionState.Closed && cn is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync();
result = await cn.QuerySingleOrDefaultAsync<PorcMonCanilla>(sql,
new { IdPublicacionParam = idPublicacion, IdCanillaParam = idCanilla, FechaParam = fecha.Date },
transaction);
}
finally
{
if (ownConnection && cn.State == ConnectionState.Open && cn is System.Data.Common.DbConnection dbConnClose) await dbConnClose.CloseAsync();
if (ownConnection) (cn as IDisposable)?.Dispose();
}
return result;
}
public async Task<PorcMonCanilla?> GetPreviousActiveAsync(int idPublicacion, int idCanilla, DateTime vigenciaDNuevo, IDbTransaction transaction)
{
const string sql = @"
SELECT TOP 1
Id_PorcMon AS IdPorcMon, Id_Publicacion AS IdPublicacion, Id_Canilla AS IdCanilla,
VigenciaD, VigenciaH, PorcMon, EsPorcentaje
FROM dbo.dist_PorcMonPagoCanilla
WHERE Id_Publicacion = @IdPublicacionParam AND Id_Canilla = @IdCanillaParam
AND VigenciaD < @VigenciaDNuevoParam
AND VigenciaH IS NULL
ORDER BY VigenciaD DESC;";
return await transaction.Connection!.QuerySingleOrDefaultAsync<PorcMonCanilla>(sql,
new { IdPublicacionParam = idPublicacion, IdCanillaParam = idCanilla, VigenciaDNuevoParam = vigenciaDNuevo.Date },
transaction);
}
public async Task<PorcMonCanilla?> CreateAsync(PorcMonCanilla nuevoItem, int idUsuario, IDbTransaction transaction)
{
const string sqlInsert = @"
INSERT INTO dbo.dist_PorcMonPagoCanilla (Id_Publicacion, Id_Canilla, VigenciaD, VigenciaH, PorcMon, EsPorcentaje)
OUTPUT INSERTED.Id_PorcMon AS IdPorcMon, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Id_Canilla AS IdCanilla,
INSERTED.VigenciaD, INSERTED.VigenciaH, INSERTED.PorcMon, INSERTED.EsPorcentaje
VALUES (@IdPublicacion, @IdCanilla, @VigenciaD, @VigenciaH, @PorcMon, @EsPorcentaje);";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_PorcMonPagoCanilla_H (Id_PorcMon, Id_Publicacion, Id_Canilla, VigenciaD, VigenciaH, PorcMon, EsPorcentaje, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdPorcMonParam, @IdPublicacionParam, @IdCanillaParam, @VigenciaDParam, @VigenciaHParam, @PorcMonParam, @EsPorcentajeParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
var inserted = await transaction.Connection!.QuerySingleAsync<PorcMonCanilla>(sqlInsert, nuevoItem, transaction);
if (inserted == null || inserted.IdPorcMon == 0) throw new DataException("Error al crear PorcMonCanilla o ID no generado.");
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdPorcMonParam = inserted.IdPorcMon,
IdPublicacionParam = inserted.IdPublicacion,
IdCanillaParam = inserted.IdCanilla,
VigenciaDParam = inserted.VigenciaD,
VigenciaHParam = inserted.VigenciaH,
PorcMonParam = inserted.PorcMon,
EsPorcentajeParam = inserted.EsPorcentaje,
IdUsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Creado"
}, transaction);
return inserted;
}
public async Task<bool> UpdateAsync(PorcMonCanilla itemAActualizar, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<PorcMonCanilla>(
@"SELECT Id_PorcMon AS IdPorcMon, Id_Publicacion AS IdPublicacion, Id_Canilla AS IdCanilla,
VigenciaD, VigenciaH, PorcMon, EsPorcentaje
FROM dbo.dist_PorcMonPagoCanilla WHERE Id_PorcMon = @IdPorcMonParam",
new { IdPorcMonParam = itemAActualizar.IdPorcMon }, transaction);
if (actual == null) throw new KeyNotFoundException("Registro PorcMonCanilla no encontrado.");
const string sqlUpdate = @"
UPDATE dbo.dist_PorcMonPagoCanilla SET
PorcMon = @PorcMon, EsPorcentaje = @EsPorcentaje, VigenciaH = @VigenciaH
WHERE Id_PorcMon = @IdPorcMon;";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_PorcMonPagoCanilla_H (Id_PorcMon, Id_Publicacion, Id_Canilla, VigenciaD, VigenciaH, PorcMon, EsPorcentaje, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdPorcMonParam, @IdPublicacionParam, @IdCanillaParam, @VigenciaDParam, @VigenciaHParam, @PorcMonParam, @EsPorcentajeParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdPorcMonParam = actual.IdPorcMon,
IdPublicacionParam = actual.IdPublicacion,
IdCanillaParam = actual.IdCanilla,
VigenciaDParam = actual.VigenciaD,
VigenciaHParam = actual.VigenciaH, // Valor ANTERIOR
PorcMonParam = actual.PorcMon, // Valor ANTERIOR
EsPorcentajeParam = actual.EsPorcentaje, // Valor ANTERIOR
IdUsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Actualizado"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlUpdate, itemAActualizar, transaction);
return rowsAffected == 1;
}
public async Task<bool> DeleteAsync(int idPorcMon, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<PorcMonCanilla>(
@"SELECT Id_PorcMon AS IdPorcMon, Id_Publicacion AS IdPublicacion, Id_Canilla AS IdCanilla,
VigenciaD, VigenciaH, PorcMon, EsPorcentaje
FROM dbo.dist_PorcMonPagoCanilla WHERE Id_PorcMon = @IdPorcMonParam",
new { IdPorcMonParam = idPorcMon }, transaction);
if (actual == null) throw new KeyNotFoundException("Registro PorcMonCanilla no encontrado para eliminar.");
const string sqlDelete = "DELETE FROM dbo.dist_PorcMonPagoCanilla WHERE Id_PorcMon = @IdPorcMonParam";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_PorcMonPagoCanilla_H (Id_PorcMon, Id_Publicacion, Id_Canilla, VigenciaD, VigenciaH, PorcMon, EsPorcentaje, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdPorcMonParam, @IdPublicacionParam, @IdCanillaParam, @VigenciaDParam, @VigenciaHParam, @PorcMonParam, @EsPorcentajeParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdPorcMonParam = actual.IdPorcMon,
IdPublicacionParam = actual.IdPublicacion,
IdCanillaParam = actual.IdCanilla,
VigenciaDParam = actual.VigenciaD,
VigenciaHParam = actual.VigenciaH,
PorcMonParam = actual.PorcMon,
EsPorcentajeParam = actual.EsPorcentaje,
IdUsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Eliminado"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdPorcMonParam = idPorcMon }, transaction);
return rowsAffected == 1;
}
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);
const string selectSql = @"
SELECT Id_PorcMon AS IdPorcMon, Id_Publicacion AS IdPublicacion, Id_Canilla AS IdCanilla,
VigenciaD, VigenciaH, PorcMon, EsPorcentaje
FROM dbo.dist_PorcMonPagoCanilla WHERE Id_Publicacion = @IdPublicacionParam";
var itemsToDelete = await transaction.Connection!.QueryAsync<PorcMonCanilla>(selectSql, new { IdPublicacionParam = 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);";
VALUES (@IdPorcMonParam, @IdPublicacionParam, @IdCanillaParam, @VigenciaDParam, @VigenciaHParam, @PorcMonParam, @EsPorcentajeParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
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)"
IdPorcMonParam = item.IdPorcMon,
IdPublicacionParam = item.IdPublicacion,
IdCanillaParam = item.IdCanilla,
VigenciaDParam = item.VigenciaD,
VigenciaHParam = item.VigenciaH,
PorcMonParam = item.PorcMon,
EsPorcentajeParam = item.EsPorcentaje,
IdUsuarioParam = idUsuarioAuditoria,
FechaModParam = DateTime.Now,
TipoModParam = "Eliminado (Cascada)"
}, transaction);
}
}
const string deleteSql = "DELETE FROM dbo.dist_PorcMonPagoCanilla WHERE Id_Publicacion = @IdPublicacion";
const string deleteSql = "DELETE FROM dbo.dist_PorcMonPagoCanilla WHERE Id_Publicacion = @IdPublicacionParam";
try
{
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacion = idPublicacion }, transaction);
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacionParam = idPublicacion }, transaction: transaction);
return true;
}
catch (System.Exception e)
catch (System.Exception ex)
{
_log.LogError(e, "Error al eliminar PorcMonCanilla por IdPublicacion: {idPublicacion}", idPublicacion);
_log.LogError(ex, "Error al eliminar PorcMonCanilla por IdPublicacion: {idPublicacion}", idPublicacion);
throw;
}
}

241
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/PorcPagoRepository.cs
View File

@@ -1,54 +1,249 @@
using Dapper; using System.Data;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Dapper;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
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; }
private readonly DbConnectionFactory _cf; // Renombrado para brevedad
private readonly ILogger<PorcPagoRepository> _log; // Renombrado para brevedad
public PorcPagoRepository(DbConnectionFactory connectionFactory, ILogger<PorcPagoRepository> logger)
{
_cf = connectionFactory;
_log = logger;
}
public async Task<IEnumerable<(PorcPago PorcPago, string NombreDistribuidor)>> GetByPublicacionIdAsync(int idPublicacion)
{
const string sql = @"
SELECT
pp.Id_Porcentaje AS IdPorcentaje, pp.Id_Publicacion AS IdPublicacion, pp.Id_Distribuidor AS IdDistribuidor,
pp.VigenciaD, pp.VigenciaH, pp.Porcentaje,
d.Nombre AS NombreDistribuidor
FROM dbo.dist_PorcPago pp
INNER JOIN dbo.dist_dtDistribuidores d ON pp.Id_Distribuidor = d.Id_Distribuidor
WHERE pp.Id_Publicacion = @IdPublicacionParam
ORDER BY d.Nombre, pp.VigenciaD DESC";
try
{
using var connection = _cf.CreateConnection();
return await connection.QueryAsync<PorcPago, string, (PorcPago, string)>(
sql,
(porcPago, nombreDist) => (porcPago, nombreDist),
new { IdPublicacionParam = idPublicacion },
splitOn: "NombreDistribuidor"
);
}
catch (Exception ex)
{
_log.LogError(ex, "Error al obtener Porcentajes de Pago por Publicacion ID: {IdPublicacion}", idPublicacion);
return Enumerable.Empty<(PorcPago, string)>();
}
}
public async Task<PorcPago?> GetByIdAsync(int idPorcentaje)
{
const string sql = @"
SELECT
Id_Porcentaje AS IdPorcentaje, Id_Publicacion AS IdPublicacion, Id_Distribuidor AS IdDistribuidor,
VigenciaD, VigenciaH, Porcentaje
FROM dbo.dist_PorcPago
WHERE Id_Porcentaje = @IdPorcentajeParam";
try
{
using var connection = _cf.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<PorcPago>(sql, new { IdPorcentajeParam = idPorcentaje });
}
catch (Exception ex)
{
_log.LogError(ex, "Error al obtener Porcentaje de Pago por ID: {IdPorcentaje}", idPorcentaje);
return null;
}
}
public async Task<PorcPago?> GetActiveByPublicacionDistribuidorAndDateAsync(int idPublicacion, int idDistribuidor, DateTime fecha, IDbTransaction? transaction = null)
{
const string sql = @"
SELECT TOP 1
Id_Porcentaje AS IdPorcentaje, Id_Publicacion AS IdPublicacion, Id_Distribuidor AS IdDistribuidor,
VigenciaD, VigenciaH, Porcentaje
FROM dbo.dist_PorcPago
WHERE Id_Publicacion = @IdPublicacionParam AND Id_Distribuidor = @IdDistribuidorParam
AND VigenciaD <= @FechaParam
AND (VigenciaH IS NULL OR VigenciaH >= @FechaParam)
ORDER BY VigenciaD DESC;";
var cn = transaction?.Connection ?? _cf.CreateConnection();
bool ownConnection = transaction == null;
PorcPago? result = null;
try
{
if (ownConnection && cn.State == ConnectionState.Closed && cn is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync();
result = await cn.QuerySingleOrDefaultAsync<PorcPago>(sql, new { IdPublicacionParam = idPublicacion, IdDistribuidorParam = idDistribuidor, FechaParam = fecha.Date }, transaction);
}
finally
{
if (ownConnection && cn.State == ConnectionState.Open && cn is System.Data.Common.DbConnection dbConnClose) await dbConnClose.CloseAsync();
if (ownConnection) (cn as IDisposable)?.Dispose();
}
return result;
}
public async Task<PorcPago?> GetPreviousActivePorcPagoAsync(int idPublicacion, int idDistribuidor, DateTime vigenciaDNuevo, IDbTransaction transaction)
{
const string sql = @"
SELECT TOP 1
Id_Porcentaje AS IdPorcentaje, Id_Publicacion AS IdPublicacion, Id_Distribuidor AS IdDistribuidor,
VigenciaD, VigenciaH, Porcentaje
FROM dbo.dist_PorcPago
WHERE Id_Publicacion = @IdPublicacionParam AND Id_Distribuidor = @IdDistribuidorParam
AND VigenciaD < @VigenciaDNuevoParam
AND VigenciaH IS NULL
ORDER BY VigenciaD DESC;";
return await transaction.Connection!.QuerySingleOrDefaultAsync<PorcPago>(sql,
new { IdPublicacionParam = idPublicacion, IdDistribuidorParam = idDistribuidor, VigenciaDNuevoParam = vigenciaDNuevo.Date },
transaction);
}
public async Task<PorcPago?> CreateAsync(PorcPago nuevoPorcPago, int idUsuario, IDbTransaction transaction)
{
const string sqlInsert = @"
INSERT INTO dbo.dist_PorcPago (Id_Publicacion, Id_Distribuidor, VigenciaD, VigenciaH, Porcentaje)
OUTPUT INSERTED.Id_Porcentaje AS IdPorcentaje, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Id_Distribuidor AS IdDistribuidor,
INSERTED.VigenciaD, INSERTED.VigenciaH, INSERTED.Porcentaje
VALUES (@IdPublicacion, @IdDistribuidor, @VigenciaD, @VigenciaH, @Porcentaje);";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_PorcPago_H (Id_Porcentaje, Id_Publicacion, Id_Distribuidor, VigenciaD, VigenciaH, Porcentaje, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdPorcentajeHist, @IdPublicacionHist, @IdDistribuidorHist, @VigenciaDHist, @VigenciaHHist, @PorcentajeHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
var inserted = await transaction.Connection!.QuerySingleAsync<PorcPago>(sqlInsert, nuevoPorcPago, transaction);
if (inserted == null || inserted.IdPorcentaje == 0) throw new DataException("Error al crear porcentaje de pago o al obtener ID.");
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdPorcentajeHist = inserted.IdPorcentaje,
IdPublicacionHist = inserted.IdPublicacion,
IdDistribuidorHist = inserted.IdDistribuidor,
VigenciaDHist = inserted.VigenciaD,
VigenciaHHist = inserted.VigenciaH,
PorcentajeHist = inserted.Porcentaje,
IdUsuarioHist = idUsuario,
FechaModHist = DateTime.Now,
TipoModHist = "Creado"
}, transaction);
return inserted;
}
public async Task<bool> UpdateAsync(PorcPago porcPagoAActualizar, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<PorcPago>(
@"SELECT Id_Porcentaje AS IdPorcentaje, Id_Publicacion AS IdPublicacion, Id_Distribuidor AS IdDistribuidor,
VigenciaD, VigenciaH, Porcentaje
FROM dbo.dist_PorcPago WHERE Id_Porcentaje = @IdPorcentajeParam",
new { IdPorcentajeParam = porcPagoAActualizar.IdPorcentaje }, transaction);
if (actual == null) throw new KeyNotFoundException("Porcentaje de pago no encontrado.");
const string sqlUpdate = @"
UPDATE dbo.dist_PorcPago SET
Porcentaje = @Porcentaje, VigenciaH = @VigenciaH
WHERE Id_Porcentaje = @IdPorcentaje;";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_PorcPago_H (Id_Porcentaje, Id_Publicacion, Id_Distribuidor, VigenciaD, VigenciaH, Porcentaje, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdPorcentajeHist, @IdPublicacionHist, @IdDistribuidorHist, @VigenciaDHist, @VigenciaHHist, @PorcentajeHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdPorcentajeHist = actual.IdPorcentaje,
IdPublicacionHist = actual.IdPublicacion,
IdDistribuidorHist = actual.IdDistribuidor,
VigenciaDHist = actual.VigenciaD,
VigenciaHHist = actual.VigenciaH, // Valor ANTERIOR de VigenciaH
PorcentajeHist = actual.Porcentaje, // Valor ANTERIOR de Porcentaje
IdUsuarioHist = idUsuario,
FechaModHist = DateTime.Now,
TipoModHist = "Actualizado"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlUpdate, porcPagoAActualizar, transaction);
return rowsAffected == 1;
}
public async Task<bool> DeleteAsync(int idPorcentaje, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<PorcPago>(
@"SELECT Id_Porcentaje AS IdPorcentaje, Id_Publicacion AS IdPublicacion, Id_Distribuidor AS IdDistribuidor,
VigenciaD, VigenciaH, Porcentaje
FROM dbo.dist_PorcPago WHERE Id_Porcentaje = @IdPorcentajeParam",
new { IdPorcentajeParam = idPorcentaje }, transaction);
if (actual == null) throw new KeyNotFoundException("Porcentaje de pago no encontrado para eliminar.");
const string sqlDelete = "DELETE FROM dbo.dist_PorcPago WHERE Id_Porcentaje = @IdPorcentajeParam";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_PorcPago_H (Id_Porcentaje, Id_Publicacion, Id_Distribuidor, VigenciaD, VigenciaH, Porcentaje, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdPorcentajeHist, @IdPublicacionHist, @IdDistribuidorHist, @VigenciaDHist, @VigenciaHHist, @PorcentajeHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdPorcentajeHist = actual.IdPorcentaje,
IdPublicacionHist = actual.IdPublicacion,
IdDistribuidorHist = actual.IdDistribuidor,
VigenciaDHist = actual.VigenciaD,
VigenciaHHist = actual.VigenciaH,
PorcentajeHist = actual.Porcentaje,
IdUsuarioHist = idUsuario,
FechaModHist = DateTime.Now,
TipoModHist = "Eliminado"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdPorcentajeParam = idPorcentaje }, transaction);
return rowsAffected == 1;
}
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);
const string selectSql = @"
SELECT Id_Porcentaje AS IdPorcentaje, Id_Publicacion AS IdPublicacion, Id_Distribuidor AS IdDistribuidor,
VigenciaD, VigenciaH, Porcentaje
FROM dbo.dist_PorcPago WHERE Id_Publicacion = @IdPublicacionParam";
var itemsToDelete = await transaction.Connection!.QueryAsync<PorcPago>(selectSql, new { IdPublicacionParam = 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);";
VALUES (@IdPorcentajeHist, @IdPublicacionHist, @IdDistribuidorHist, @VigenciaDHist, @VigenciaHHist, @PorcentajeHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
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)"
IdPorcentajeHist = item.IdPorcentaje,
IdPublicacionHist = item.IdPublicacion,
IdDistribuidorHist = item.IdDistribuidor,
VigenciaDHist = item.VigenciaD,
VigenciaHHist = item.VigenciaH,
PorcentajeHist = item.Porcentaje,
IdUsuarioHist = idUsuarioAuditoria,
FechaModHist = DateTime.Now,
TipoModHist = "Eliminado (Cascada)"
}, transaction);
}
}
const string deleteSql = "DELETE FROM dbo.dist_PorcPago WHERE Id_Publicacion = @IdPublicacion";
const string deleteSql = "DELETE FROM dbo.dist_PorcPago WHERE Id_Publicacion = @IdPublicacionParam";
try
{
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacion = idPublicacion }, transaction);
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacionParam = idPublicacion }, transaction: transaction);
return true;
}
catch (System.Exception e)
catch (System.Exception ex)
{
_log.LogError(e, "Error al eliminar PorcPago por IdPublicacion: {idPublicacion}", idPublicacion);
_log.LogError(ex, "Error al eliminar PorcPago por IdPublicacion: {idPublicacion}", idPublicacion);
throw;
}
}

216
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/PrecioRepository.cs
View File

@@ -1,6 +1,7 @@
using Dapper;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
@@ -21,66 +22,127 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
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 });
const string sql = @"
SELECT
Id_Precio AS IdPrecio, Id_Publicacion AS IdPublicacion, VigenciaD, VigenciaH,
Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo
FROM dbo.dist_Precios
WHERE Id_Publicacion = @IdPublicacionParam
ORDER BY VigenciaD DESC";
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.QueryAsync<Precio>(sql, new { IdPublicacionParam = idPublicacion });
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener precios por IdPublicacion: {IdPublicacion}", idPublicacion);
return Enumerable.Empty<Precio>();
}
}
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 });
const string sql = @"
SELECT
Id_Precio AS IdPrecio, Id_Publicacion AS IdPublicacion, VigenciaD, VigenciaH,
Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo
FROM dbo.dist_Precios
WHERE Id_Precio = @IdPrecioParam";
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<Precio>(sql, new { IdPrecioParam = idPrecio });
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener precio por ID: {idPrecio}", idPrecio);
return null;
}
}
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
SELECT TOP 1
Id_Precio AS IdPrecio, Id_Publicacion AS IdPublicacion, VigenciaD, VigenciaH,
Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo
FROM dbo.dist_Precios
WHERE Id_Publicacion = @IdPublicacionParam AND VigenciaD <= @FechaParam
AND (VigenciaH IS NULL OR VigenciaH >= @FechaParam)
ORDER BY VigenciaD DESC;";
var cn = transaction?.Connection ?? _connectionFactory.CreateConnection();
return await cn.QuerySingleOrDefaultAsync<Precio>(sql, new { IdPublicacion = idPublicacion, Fecha = fecha }, transaction);
bool ownConnection = transaction == null;
Precio? result = null;
try
{
if (ownConnection && cn.State == ConnectionState.Closed && cn is System.Data.Common.DbConnection dbConn)
{
await dbConn.OpenAsync();
}
result = await cn.QuerySingleOrDefaultAsync<Precio>(sql,
new { IdPublicacionParam = idPublicacion, FechaParam = fecha.Date },
transaction);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error en GetActiveByPublicacionAndDateAsync. IdPublicacion: {IdPublicacion}, Fecha: {Fecha}", idPublicacion, fecha);
throw; // Re-lanzar para que el servicio lo maneje si es necesario
}
finally
{
if (ownConnection && cn.State == ConnectionState.Open && cn is System.Data.Common.DbConnection dbConnClose)
{
await dbConnClose.CloseAsync();
}
if (ownConnection) (cn as IDisposable)?.Dispose();
}
return result;
}
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 *
SELECT TOP 1
Id_Precio AS IdPrecio, Id_Publicacion AS IdPublicacion, VigenciaD, VigenciaH,
Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo
FROM dbo.dist_Precios
WHERE Id_Publicacion = @IdPublicacion
AND VigenciaD < @VigenciaDNuevo
WHERE Id_Publicacion = @IdPublicacionParam
AND VigenciaD < @VigenciaDNuevoParam
AND VigenciaH IS NULL
ORDER BY VigenciaD DESC;";
return await transaction.Connection!.QuerySingleOrDefaultAsync<Precio>(sql, new { IdPublicacion = idPublicacion, VigenciaDNuevo = vigenciaDNuevo }, transaction);
return await transaction.Connection!.QuerySingleOrDefaultAsync<Precio>(sql,
new { IdPublicacionParam = idPublicacion, VigenciaDNuevoParam = vigenciaDNuevo.Date },
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.*
OUTPUT INSERTED.Id_Precio AS IdPrecio, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.VigenciaD, INSERTED.VigenciaH,
INSERTED.Lunes, INSERTED.Martes, INSERTED.Miercoles, INSERTED.Jueves, INSERTED.Viernes, INSERTED.Sabado, INSERTED.Domingo
VALUES (@IdPublicacion, @VigenciaD, @VigenciaH, @Lunes, @Martes, @Miercoles, @Jueves, @Viernes, @Sabado, @Domingo);";
var inserted = await transaction.Connection!.QuerySingleAsync<Precio>(sqlInsert, nuevoPrecio, transaction);
if (inserted == null || inserted.IdPrecio == 0) throw new DataException("Error al crear precio o al obtener el ID generado.");
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.");
VALUES (@IdPrecioHist, @IdPublicacionHist, @VigenciaDHist, @VigenciaHHist, @LunesHist, @MartesHist, @MiercolesHist, @JuevesHist, @ViernesHist, @SabadoHist, @DomingoHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
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"
IdPrecioHist = inserted.IdPrecio,
IdPublicacionHist = inserted.IdPublicacion,
VigenciaDHist = inserted.VigenciaD,
VigenciaHHist = inserted.VigenciaH,
LunesHist = inserted.Lunes, MartesHist = inserted.Martes, MiercolesHist = inserted.Miercoles, JuevesHist = inserted.Jueves,
ViernesHist = inserted.Viernes, SabadoHist = inserted.Sabado, DomingoHist = inserted.Domingo,
IdUsuarioHist = idUsuario,
FechaModHist = DateTime.Now,
TipoModHist = "Creado"
}, transaction);
return inserted;
}
@@ -88,28 +150,32 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
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);
@"SELECT Id_Precio AS IdPrecio, Id_Publicacion AS IdPublicacion, VigenciaD, VigenciaH,
Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo
FROM dbo.dist_Precios WHERE Id_Precio = @IdPrecioParam", // Usar parámetro con alias
new { IdPrecioParam = 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);";
VALUES (@IdPrecioHist, @IdPublicacionHist, @VigenciaDHist, @VigenciaHHist, @LunesHist, @MartesHist, @MiercolesHist, @JuevesHist, @ViernesHist, @SabadoHist, @DomingoHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
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
IdPrecioHist = actual.IdPrecio,
IdPublicacionHist = actual.IdPublicacion,
VigenciaDHist = actual.VigenciaD,
VigenciaHHist = actual.VigenciaH,
LunesHist = actual.Lunes, MartesHist = actual.Martes, MiercolesHist = actual.Miercoles, JuevesHist = actual.Jueves,
ViernesHist = actual.Viernes, SabadoHist = actual.Sabado, DomingoHist = actual.Domingo,
IdUsuarioHist = idUsuario,
FechaModHist = DateTime.Now,
TipoModHist = "Actualizado"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlUpdate, precioAActualizar, transaction);
@@ -119,53 +185,71 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
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);
@"SELECT Id_Precio AS IdPrecio, Id_Publicacion AS IdPublicacion, VigenciaD, VigenciaH,
Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo
FROM dbo.dist_Precios WHERE Id_Precio = @IdPrecioParam", new { IdPrecioParam = 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 sqlDelete = "DELETE FROM dbo.dist_Precios WHERE Id_Precio = @IdPrecioParam"; // Usar parámetro con alias
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);";
VALUES (@IdPrecioHist, @IdPublicacionHist, @VigenciaDHist, @VigenciaHHist, @LunesHist, @MartesHist, @MiercolesHist, @JuevesHist, @ViernesHist, @SabadoHist, @DomingoHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
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"
IdPrecioHist = actual.IdPrecio,
IdPublicacionHist = actual.IdPublicacion,
VigenciaDHist = actual.VigenciaD,
VigenciaHHist = actual.VigenciaH,
LunesHist = actual.Lunes, MartesHist = actual.Martes, MiercolesHist = actual.Miercoles, JuevesHist = actual.Jueves,
ViernesHist = actual.Viernes, SabadoHist = actual.Sabado, DomingoHist = actual.Domingo,
IdUsuarioHist = idUsuario,
FechaModHist = DateTime.Now,
TipoModHist = "Eliminado"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdPrecio = idPrecio }, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdPrecioParam = idPrecio }, transaction); // Usar parámetro con alias
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);
public async Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction)
{
const string selectSql = @"
SELECT
Id_Precio AS IdPrecio, Id_Publicacion AS IdPublicacion, VigenciaD, VigenciaH,
Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo
FROM dbo.dist_Precios WHERE Id_Publicacion = @IdPublicacionParam";
var itemsToDelete = await transaction.Connection!.QueryAsync<Precio>(selectSql, new { IdPublicacionParam = 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)
if (itemsToDelete.Any())
{
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
const string insertHistoricoSql = @"
INSERT INTO dbo.dist_Precios_H
(Id_Precio, Id_Publicacion, VigenciaD, VigenciaH, Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdPrecioHist, @IdPublicacionHist, @VigenciaDHist, @VigenciaHHist, @LunesHist, @MartesHist, @MiercolesHist, @JuevesHist, @ViernesHist, @SabadoHist, @DomingoHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
foreach (var item in itemsToDelete)
{
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);
await transaction.Connection!.ExecuteAsync(insertHistoricoSql, new
{
IdPrecioHist = item.IdPrecio,
IdPublicacionHist = item.IdPublicacion,
VigenciaDHist = item.VigenciaD,
VigenciaHHist = item.VigenciaH,
LunesHist = item.Lunes, MartesHist = item.Martes, MiercolesHist = item.Miercoles, JuevesHist = item.Jueves,
ViernesHist = item.Viernes, SabadoHist = item.Sabado, DomingoHist = item.Domingo,
IdUsuarioHist = idUsuarioAuditoria,
FechaModHist = DateTime.Now,
TipoModHist = "Eliminado (Cascada)"
}, transaction);
}
}
const string sql = "DELETE FROM dbo.dist_Precios WHERE Id_Publicacion = @IdPublicacion";
const string deleteSql = "DELETE FROM dbo.dist_Precios WHERE Id_Publicacion = @IdPublicacionParam";
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ó
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacionParam = idPublicacion }, transaction: transaction);
return true;
}
catch (System.Exception ex)
{

226
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/PubliSeccionRepository.cs
View File

@@ -1,53 +1,237 @@
using Dapper;
using System.Data;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System;
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 PubliSeccionRepository : IPubliSeccionRepository
{
private readonly DbConnectionFactory _cf; private readonly ILogger<PubliSeccionRepository> _log;
public PubliSeccionRepository(DbConnectionFactory cf, ILogger<PubliSeccionRepository> log) { _cf = cf; _log = log; }
private readonly DbConnectionFactory _cf;
private readonly ILogger<PubliSeccionRepository> _log;
public PubliSeccionRepository(DbConnectionFactory connectionFactory, ILogger<PubliSeccionRepository> logger)
{
_cf = connectionFactory;
_log = logger;
}
public async Task<IEnumerable<PubliSeccion>> GetByPublicacionIdAsync(int idPublicacion, bool? soloActivas = null)
{
var sqlBuilder = new StringBuilder(@"
SELECT
Id_Seccion AS IdSeccion, Id_Publicacion AS IdPublicacion, Nombre, Estado
FROM dbo.dist_dtPubliSecciones
WHERE Id_Publicacion = @IdPublicacionParam");
if (soloActivas.HasValue)
{
sqlBuilder.Append(soloActivas.Value ? " AND Estado = 1" : " AND Estado = 0");
}
sqlBuilder.Append(" ORDER BY Nombre;");
try
{
using var connection = _cf.CreateConnection();
return await connection.QueryAsync<PubliSeccion>(sqlBuilder.ToString(), new { IdPublicacionParam = idPublicacion });
}
catch (Exception ex)
{
_log.LogError(ex, "Error al obtener Secciones por Publicacion ID: {IdPublicacion}", idPublicacion);
return Enumerable.Empty<PubliSeccion>();
}
}
public async Task<PubliSeccion?> GetByIdAsync(int idSeccion)
{
const string sql = @"
SELECT
Id_Seccion AS IdSeccion, Id_Publicacion AS IdPublicacion, Nombre, Estado
FROM dbo.dist_dtPubliSecciones
WHERE Id_Seccion = @IdSeccionParam";
try
{
using var connection = _cf.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<PubliSeccion>(sql, new { IdSeccionParam = idSeccion });
}
catch (Exception ex)
{
_log.LogError(ex, "Error al obtener Sección por ID: {IdSeccion}", idSeccion);
return null;
}
}
public async Task<bool> ExistsByNameInPublicacionAsync(string nombre, int idPublicacion, int? excludeIdSeccion = null)
{
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtPubliSecciones WHERE Nombre = @NombreParam AND Id_Publicacion = @IdPublicacionParam");
var parameters = new DynamicParameters();
parameters.Add("NombreParam", nombre);
parameters.Add("IdPublicacionParam", idPublicacion);
if (excludeIdSeccion.HasValue)
{
sqlBuilder.Append(" AND Id_Seccion != @ExcludeIdSeccionParam");
parameters.Add("ExcludeIdSeccionParam", excludeIdSeccion.Value);
}
try
{
using var connection = _cf.CreateConnection();
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
}
catch (Exception ex)
{
_log.LogError(ex, "Error en ExistsByNameInPublicacionAsync. Nombre: {Nombre}, PubID: {IdPublicacion}", nombre, idPublicacion);
return true;
}
}
public async Task<bool> IsInUseAsync(int idSeccion)
{
// Verificar en bob_RegPublicaciones y bob_StockBobinas (si Id_Seccion se usa allí)
using var connection = _cf.CreateConnection();
string[] checkQueries = {
"SELECT TOP 1 1 FROM dbo.bob_RegPublicaciones WHERE Id_Seccion = @IdSeccionParam",
"SELECT TOP 1 1 FROM dbo.bob_StockBobinas WHERE Id_Seccion = @IdSeccionParam"
};
try
{
foreach (var query in checkQueries)
{
if (await connection.ExecuteScalarAsync<int?>(query, new { IdSeccionParam = idSeccion }) == 1) return true;
}
return false;
}
catch (Exception ex)
{
_log.LogError(ex, "Error en IsInUseAsync para PubliSeccion ID: {idSeccion}", idSeccion);
return true;
}
}
public async Task<PubliSeccion?> CreateAsync(PubliSeccion nuevaSeccion, int idUsuario, IDbTransaction transaction)
{
const string sqlInsert = @"
INSERT INTO dbo.dist_dtPubliSecciones (Id_Publicacion, Nombre, Estado)
OUTPUT INSERTED.Id_Seccion AS IdSeccion, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Nombre, INSERTED.Estado
VALUES (@IdPublicacion, @Nombre, @Estado);";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_dtPubliSecciones_H (Id_Seccion, Id_Publicacion, Nombre, Estado, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdSeccionParam, @IdPublicacionParam, @NombreParam, @EstadoParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
var inserted = await transaction.Connection!.QuerySingleAsync<PubliSeccion>(sqlInsert, nuevaSeccion, transaction);
if (inserted == null || inserted.IdSeccion == 0) throw new DataException("Error al crear sección o ID no generado.");
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdSeccionParam = inserted.IdSeccion,
IdPublicacionParam = inserted.IdPublicacion,
NombreParam = inserted.Nombre,
EstadoParam = inserted.Estado,
IdUsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Creada"
}, transaction);
return inserted;
}
public async Task<bool> UpdateAsync(PubliSeccion seccionAActualizar, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<PubliSeccion>(
@"SELECT Id_Seccion AS IdSeccion, Id_Publicacion AS IdPublicacion, Nombre, Estado
FROM dbo.dist_dtPubliSecciones WHERE Id_Seccion = @IdSeccionParam",
new { IdSeccionParam = seccionAActualizar.IdSeccion }, transaction);
if (actual == null) throw new KeyNotFoundException("Sección no encontrada.");
const string sqlUpdate = @"
UPDATE dbo.dist_dtPubliSecciones SET
Nombre = @Nombre, Estado = @Estado
WHERE Id_Seccion = @IdSeccion;";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_dtPubliSecciones_H (Id_Seccion, Id_Publicacion, Nombre, Estado, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdSeccionParam, @IdPublicacionParam, @NombreParam, @EstadoParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdSeccionParam = actual.IdSeccion,
IdPublicacionParam = actual.IdPublicacion, // Tomar de 'actual' ya que no se modifica
NombreParam = actual.Nombre, // Valor ANTERIOR
EstadoParam = actual.Estado, // Valor ANTERIOR
IdUsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Actualizada"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlUpdate, seccionAActualizar, transaction);
return rowsAffected == 1;
}
public async Task<bool> DeleteAsync(int idSeccion, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<PubliSeccion>(
@"SELECT Id_Seccion AS IdSeccion, Id_Publicacion AS IdPublicacion, Nombre, Estado
FROM dbo.dist_dtPubliSecciones WHERE Id_Seccion = @IdSeccionParam",
new { IdSeccionParam = idSeccion }, transaction);
if (actual == null) throw new KeyNotFoundException("Sección no encontrada para eliminar.");
const string sqlDelete = "DELETE FROM dbo.dist_dtPubliSecciones WHERE Id_Seccion = @IdSeccionParam";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_dtPubliSecciones_H (Id_Seccion, Id_Publicacion, Nombre, Estado, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdSeccionParam, @IdPublicacionParam, @NombreParam, @EstadoParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdSeccionParam = actual.IdSeccion,
IdPublicacionParam = actual.IdPublicacion,
NombreParam = actual.Nombre,
EstadoParam = actual.Estado,
IdUsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Eliminada"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdSeccionParam = idSeccion }, transaction);
return rowsAffected == 1;
}
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);
const string selectSql = @"
SELECT Id_Seccion AS IdSeccion, Id_Publicacion AS IdPublicacion, Nombre, Estado
FROM dbo.dist_dtPubliSecciones WHERE Id_Publicacion = @IdPublicacionParam";
var itemsToDelete = await transaction.Connection!.QueryAsync<PubliSeccion>(selectSql, new { IdPublicacionParam = 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);";
VALUES (@IdSeccionParam, @IdPublicacionParam, @NombreParam, @EstadoParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
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)"
IdSeccionParam = item.IdSeccion,
IdPublicacionParam = item.IdPublicacion,
NombreParam = item.Nombre,
EstadoParam = item.Estado,
IdUsuarioParam = idUsuarioAuditoria,
FechaModParam = DateTime.Now,
TipoModParam = "Eliminado (Cascada)"
}, transaction);
}
}
const string deleteSql = "DELETE FROM dbo.dist_dtPubliSecciones WHERE Id_Publicacion = @IdPublicacion";
const string deleteSql = "DELETE FROM dbo.dist_dtPubliSecciones WHERE Id_Publicacion = @IdPublicacionParam";
try
{
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacion = idPublicacion }, transaction);
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacionParam = idPublicacion }, transaction: transaction);
return true;
}
catch (System.Exception e)
catch (System.Exception ex)
{
_log.LogError(e, "Error al eliminar PubliSecciones por IdPublicacion: {idPublicacion}", idPublicacion);
_log.LogError(ex, "Error al eliminar PubliSecciones por IdPublicacion: {idPublicacion}", idPublicacion);
throw;
}
}

184
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/PublicacionRepository.cs
View File

@@ -1,6 +1,8 @@
// src/Data/Repositories/PublicacionRepository.cs
using Dapper;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System; // Añadido para Exception
using System.Collections.Generic;
using System.Data;
using System.Linq;
@@ -23,7 +25,10 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
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
SELECT
p.Id_Publicacion AS IdPublicacion, p.Nombre, p.Observacion, p.Id_Empresa AS IdEmpresa,
p.CtrlDevoluciones, p.Habilitada,
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");
@@ -31,33 +36,34 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
if (soloHabilitadas.HasValue)
{
sqlBuilder.Append(soloHabilitadas.Value ? " AND p.Habilitada = 1" : " AND (p.Habilitada = 0 OR p.Habilitada IS NULL)");
sqlBuilder.Append(soloHabilitadas.Value ? " AND (p.Habilitada = 1 OR p.Habilitada IS NULL)" : " AND p.Habilitada = 0");
}
if (!string.IsNullOrWhiteSpace(nombreFilter))
{
sqlBuilder.Append(" AND p.Nombre LIKE @Nombre");
parameters.Add("Nombre", $"%{nombreFilter}%");
sqlBuilder.Append(" AND p.Nombre LIKE @NombreParam");
parameters.Add("NombreParam", $"%{nombreFilter}%");
}
if (idEmpresaFilter.HasValue && idEmpresaFilter > 0)
{
sqlBuilder.Append(" AND p.Id_Empresa = @IdEmpresa");
parameters.Add("IdEmpresa", idEmpresaFilter.Value);
sqlBuilder.Append(" AND p.Id_Empresa = @IdEmpresaParam");
parameters.Add("IdEmpresaParam", idEmpresaFilter.Value);
}
sqlBuilder.Append(" ORDER BY p.Nombre;");
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.QueryAsync<Publicacion, string, (Publicacion, string)>(
var result = await connection.QueryAsync<Publicacion, string, (Publicacion, string)>(
sqlBuilder.ToString(),
(pub, empNombre) => (pub, empNombre),
(publicacion, nombreEmpresa) => (publicacion, nombreEmpresa),
parameters,
splitOn: "NombreEmpresa"
);
return result;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener todas las Publicaciones.");
_logger.LogError(ex, "Error al obtener todas las Publicaciones. Filtros: Nombre='{NombreFilter}', IdEmpresa='{IdEmpresaFilter}', SoloHabilitadas='{SoloHabilitadas}'", nombreFilter, idEmpresaFilter, soloHabilitadas);
return Enumerable.Empty<(Publicacion, string)>();
}
}
@@ -65,17 +71,20 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
public async Task<(Publicacion? Publicacion, string? NombreEmpresa)> GetByIdAsync(int id)
{
const string sql = @"
SELECT p.*, e.Nombre AS NombreEmpresa
SELECT
p.Id_Publicacion AS IdPublicacion, p.Nombre, p.Observacion, p.Id_Empresa AS IdEmpresa,
p.CtrlDevoluciones, p.Habilitada,
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";
WHERE p.Id_Publicacion = @IdParam";
try
{
using var connection = _connectionFactory.CreateConnection();
var result = await connection.QueryAsync<Publicacion, string, (Publicacion, string)>(
var result = await connection.QueryAsync<Publicacion, string, (Publicacion?, string?)>(
sql,
(pub, empNombre) => (pub, empNombre),
new { Id = id },
(publicacion, nombreEmpresa) => (publicacion, nombreEmpresa),
new { IdParam = id },
splitOn: "NombreEmpresa"
);
return result.SingleOrDefault();
@@ -86,77 +95,107 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
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 });
const string sql = @"
SELECT
Id_Publicacion AS IdPublicacion, Nombre, Observacion, Id_Empresa AS IdEmpresa,
CtrlDevoluciones, Habilitada
FROM dbo.dist_dtPublicaciones
WHERE Id_Publicacion = @IdParam";
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<Publicacion>(sql, new { IdParam = id });
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener Publicación (simple) por ID: {IdPublicacion}", id);
return null;
}
}
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 sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtPublicaciones WHERE Nombre = @NombreParam AND Id_Empresa = @IdEmpresaParam");
var parameters = new DynamicParameters();
parameters.Add("Nombre", nombre);
parameters.Add("IdEmpresa", idEmpresa);
parameters.Add("NombreParam", nombre);
parameters.Add("IdEmpresaParam", idEmpresa);
if (excludeIdPublicacion.HasValue)
{
sqlBuilder.Append(" AND Id_Publicacion != @ExcludeId");
parameters.Add("ExcludeId", excludeIdPublicacion.Value);
sqlBuilder.Append(" AND Id_Publicacion != @ExcludeIdParam");
parameters.Add("ExcludeIdParam", excludeIdPublicacion.Value);
}
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error en ExistsByNameAndEmpresaAsync. Nombre: {Nombre}, IdEmpresa: {IdEmpresa}", nombre, idEmpresa);
return true; // Asumir que existe en caso de error para prevenir duplicados
}
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"
"SELECT TOP 1 1 FROM dbo.dist_EntradasSalidas WHERE Id_Publicacion = @IdParam",
"SELECT TOP 1 1 FROM dbo.dist_EntradasSalidasCanillas WHERE Id_Publicacion = @IdParam",
"SELECT TOP 1 1 FROM dbo.dist_Precios WHERE Id_Publicacion = @IdParam",
"SELECT TOP 1 1 FROM dbo.dist_RecargoZona WHERE Id_Publicacion = @IdParam",
"SELECT TOP 1 1 FROM dbo.dist_PorcPago WHERE Id_Publicacion = @IdParam",
"SELECT TOP 1 1 FROM dbo.dist_PorcMonPagoCanilla WHERE Id_Publicacion = @IdParam",
"SELECT TOP 1 1 FROM dbo.dist_dtPubliSecciones WHERE Id_Publicacion = @IdParam",
"SELECT TOP 1 1 FROM dbo.bob_RegPublicaciones WHERE Id_Publicacion = @IdParam",
"SELECT TOP 1 1 FROM dbo.bob_StockBobinas WHERE Id_Publicacion = @IdParam"
};
foreach (var query in checkQueries)
try
{
if (await connection.ExecuteScalarAsync<int?>(query, new { Id = id }) == 1) return true;
foreach (var query in checkQueries)
{
if (await connection.ExecuteScalarAsync<int?>(query, new { IdParam = id }) == 1) return true;
}
return false;
}
catch (Exception ex)
{
_logger.LogError(ex, "Error en IsInUseAsync para Publicacion ID: {IdPublicacion}", id);
return true; // Asumir en uso si hay error de BD
}
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.*
OUTPUT INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Nombre, INSERTED.Observacion, INSERTED.Id_Empresa AS IdEmpresa, INSERTED.CtrlDevoluciones, INSERTED.Habilitada
VALUES (@Nombre, @Observacion, @IdEmpresa, @CtrlDevoluciones, @Habilitada);";
var connection = transaction.Connection!;
var inserted = await connection.QuerySingleAsync<Publicacion>(sqlInsert, nuevaPublicacion, transaction);
if (inserted == null || inserted.IdPublicacion == 0) throw new DataException("Error al crear la publicación o al obtener el ID generado.");
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.");
VALUES (@IdPublicacionParam, @NombreParam, @ObservacionParam, @IdEmpresaParam, @HabilitadaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
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"
IdPublicacionParam = inserted.IdPublicacion,
NombreParam = inserted.Nombre,
ObservacionParam = inserted.Observacion,
IdEmpresaParam = inserted.IdEmpresa,
HabilitadaParam = inserted.Habilitada ?? true,
IdUsuarioParam = idUsuario, // Renombrado para claridad con el parámetro de la función
FechaModParam = DateTime.Now,
TipoModParam = "Creada"
}, transaction);
return inserted;
}
@@ -165,27 +204,33 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
var connection = transaction.Connection!;
var actual = await connection.QuerySingleOrDefaultAsync<Publicacion>(
"SELECT * FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdPublicacion",
new { publicacionAActualizar.IdPublicacion }, transaction);
@"SELECT Id_Publicacion AS IdPublicacion, Nombre, Observacion, Id_Empresa AS IdEmpresa, CtrlDevoluciones, Habilitada
FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdPublicacionParam", // Usar alias
new { IdPublicacionParam = publicacionAActualizar.IdPublicacion }, transaction);
if (actual == null) throw new KeyNotFoundException("Publicación no encontrada.");
publicacionAActualizar.Habilitada ??= true; // Asegurar que no sea null
publicacionAActualizar.Habilitada ??= true;
const string sqlUpdate = @"
UPDATE dbo.dist_dtPublicaciones SET
Nombre = @Nombre, Observacion = @Observacion, Id_Empresa = @IdEmpresa,
CtrlDevoluciones = @CtrlDevoluciones, Habilitada = @Habilitada
WHERE Id_Publicacion = @IdPublicacion;";
WHERE Id_Publicacion = @IdPublicacion;"; // Usar nombres de propiedad del objeto
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);";
VALUES (@IdPublicacionParam, @NombreParam, @ObservacionParam, @IdEmpresaParam, @HabilitadaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
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"
IdPublicacionParam = actual.IdPublicacion,
NombreParam = actual.Nombre, // Valor ANTES de la actualización
ObservacionParam = actual.Observacion,
IdEmpresaParam = actual.IdEmpresa,
HabilitadaParam = actual.Habilitada ?? true,
IdUsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Actualizada"
}, transaction);
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, publicacionAActualizar, transaction);
@@ -196,23 +241,30 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
var connection = transaction.Connection!;
var actual = await connection.QuerySingleOrDefaultAsync<Publicacion>(
"SELECT * FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @Id", new { Id = id }, transaction);
@"SELECT Id_Publicacion AS IdPublicacion, Nombre, Observacion, Id_Empresa AS IdEmpresa, CtrlDevoluciones, Habilitada
FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdParam", // Usar alias
new { IdParam = 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 sqlDelete = "DELETE FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdParam";
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);";
VALUES (@IdPublicacionParam, @NombreParam, @ObservacionParam, @IdEmpresaParam, @HabilitadaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
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"
IdPublicacionParam = actual.IdPublicacion,
NombreParam = actual.Nombre,
ObservacionParam = actual.Observacion,
IdEmpresaParam = actual.IdEmpresa,
HabilitadaParam = actual.Habilitada ?? true,
IdUsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Eliminada"
}, transaction);
var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { Id = id }, transaction);
var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { IdParam = id }, transaction);
return rowsAffected == 1;
}
}

278
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/RecargoZonaRepository.cs
View File

@@ -1,16 +1,18 @@
// src/Data/Repositories/RecargoZonaRepository.cs
using Dapper;
using System.Data;
using System.Threading.Tasks;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using GestionIntegral.Api.Models.Distribucion; // Asegúrate que esta directiva using esté presente
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq; // Necesario para .Any()
using System.Threading.Tasks;
namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
public class RecargoZonaRepository : IRecargoZonaRepository
{
private readonly DbConnectionFactory _connectionFactory; // _cf
private readonly ILogger<RecargoZonaRepository> _logger; // _log
private readonly DbConnectionFactory _connectionFactory;
private readonly ILogger<RecargoZonaRepository> _logger;
public RecargoZonaRepository(DbConnectionFactory connectionFactory, ILogger<RecargoZonaRepository> logger)
{
@@ -18,47 +20,245 @@ namespace GestionIntegral.Api.Data.Repositories.Distribucion
_logger = logger;
}
public async Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction)
public async Task<IEnumerable<(RecargoZona Recargo, string NombreZona)>> GetByPublicacionIdAsync(int idPublicacion)
{
// 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";
const string sql = @"
SELECT
rz.Id_Recargo AS IdRecargo, rz.Id_Publicacion AS IdPublicacion, rz.Id_Zona AS IdZona,
rz.VigenciaD, rz.VigenciaH, rz.Valor,
z.Nombre AS NombreZona
FROM dbo.dist_RecargoZona rz
INNER JOIN dbo.dist_dtZonas z ON rz.Id_Zona = z.Id_Zona
WHERE rz.Id_Publicacion = @IdPublicacionParam
ORDER BY z.Nombre, rz.VigenciaD DESC";
try
{
await transaction.Connection!.ExecuteAsync(sql, new { IdPublicacion = idPublicacion }, transaction: transaction);
return true; // Se intentó la operación
using var connection = _connectionFactory.CreateConnection();
return await connection.QueryAsync<RecargoZona, string, (RecargoZona, string)>(
sql,
(recargo, nombreZona) => (recargo, nombreZona),
new { IdPublicacionParam = idPublicacion },
splitOn: "NombreZona"
);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener Recargos por Zona para Publicacion ID: {IdPublicacion}", idPublicacion);
return Enumerable.Empty<(RecargoZona, string)>();
}
}
public async Task<RecargoZona?> GetByIdAsync(int idRecargo)
{
const string sql = @"
SELECT
Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona,
VigenciaD, VigenciaH, Valor
FROM dbo.dist_RecargoZona
WHERE Id_Recargo = @IdRecargoParam";
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<RecargoZona>(sql, new { IdRecargoParam = idRecargo });
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener Recargo por Zona por ID: {IdRecargo}", idRecargo);
return null;
}
}
public async Task<RecargoZona?> GetActiveByPublicacionZonaAndDateAsync(int idPublicacion, int idZona, DateTime fecha, IDbTransaction? transaction = null)
{
const string sql = @"
SELECT TOP 1
Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona,
VigenciaD, VigenciaH, Valor
FROM dbo.dist_RecargoZona
WHERE Id_Publicacion = @IdPublicacionParam AND Id_Zona = @IdZonaParam
AND VigenciaD <= @FechaParam
AND (VigenciaH IS NULL OR VigenciaH >= @FechaParam)
ORDER BY VigenciaD DESC;";
var cn = transaction?.Connection ?? _connectionFactory.CreateConnection();
bool ownConnection = transaction == null;
RecargoZona? result = null;
try
{
if (ownConnection && cn.State == ConnectionState.Closed && cn is System.Data.Common.DbConnection dbConn)
{
await dbConn.OpenAsync();
}
result = await cn.QuerySingleOrDefaultAsync<RecargoZona>(sql,
new { IdPublicacionParam = idPublicacion, IdZonaParam = idZona, FechaParam = fecha.Date },
transaction);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error en GetActiveByPublicacionZonaAndDateAsync. IdPublicacion: {IdPublicacion}, IdZona: {IdZona}, Fecha: {Fecha}", idPublicacion, idZona, fecha);
throw;
}
finally
{
if (ownConnection && cn.State == ConnectionState.Open && cn is System.Data.Common.DbConnection dbConnClose)
{
await dbConnClose.CloseAsync();
}
if (ownConnection) (cn as IDisposable)?.Dispose();
}
return result;
}
public async Task<RecargoZona?> GetPreviousActiveRecargoAsync(int idPublicacion, int idZona, DateTime vigenciaDNuevo, IDbTransaction transaction)
{
const string sql = @"
SELECT TOP 1
Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona,
VigenciaD, VigenciaH, Valor
FROM dbo.dist_RecargoZona
WHERE Id_Publicacion = @IdPublicacionParam AND Id_Zona = @IdZonaParam
AND VigenciaD < @VigenciaDNuevoParam
AND VigenciaH IS NULL
ORDER BY VigenciaD DESC;";
return await transaction.Connection!.QuerySingleOrDefaultAsync<RecargoZona>(sql,
new { IdPublicacionParam = idPublicacion, IdZonaParam = idZona, VigenciaDNuevoParam = vigenciaDNuevo.Date },
transaction);
}
public async Task<RecargoZona?> CreateAsync(RecargoZona nuevoRecargo, int idUsuario, IDbTransaction transaction)
{
const string sqlInsert = @"
INSERT INTO dbo.dist_RecargoZona (Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor)
OUTPUT INSERTED.Id_Recargo AS IdRecargo, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Id_Zona AS IdZona,
INSERTED.VigenciaD, INSERTED.VigenciaH, INSERTED.Valor
VALUES (@IdPublicacion, @IdZona, @VigenciaD, @VigenciaH, @Valor);";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_RecargoZona_H (Id_Recargo, Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdRecargoParam, @IdPublicacionParam, @IdZonaParam, @VigenciaDParam, @VigenciaHParam, @ValorParam, @Id_UsuarioParam, @FechaModParam, @TipoModParam);";
var inserted = await transaction.Connection!.QuerySingleAsync<RecargoZona>(sqlInsert, nuevoRecargo, transaction);
if (inserted == null || inserted.IdRecargo == 0) throw new DataException("Error al crear recargo por zona o al obtener el ID generado.");
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdRecargoParam = inserted.IdRecargo,
IdPublicacionParam = inserted.IdPublicacion,
IdZonaParam = inserted.IdZona,
VigenciaDParam = inserted.VigenciaD,
VigenciaHParam = inserted.VigenciaH,
ValorParam = inserted.Valor,
Id_UsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Creado"
}, transaction);
return inserted;
}
public async Task<bool> UpdateAsync(RecargoZona recargoAActualizar, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<RecargoZona>(
@"SELECT Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona,
VigenciaD, VigenciaH, Valor
FROM dbo.dist_RecargoZona WHERE Id_Recargo = @IdRecargoParam", // Usar parámetro con alias
new { IdRecargoParam = recargoAActualizar.IdRecargo }, transaction);
if (actual == null) throw new KeyNotFoundException("Recargo por zona no encontrado.");
const string sqlUpdate = @"
UPDATE dbo.dist_RecargoZona SET
Valor = @Valor, VigenciaH = @VigenciaH
WHERE Id_Recargo = @IdRecargo;";
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_RecargoZona_H (Id_Recargo, Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdRecargoParam, @IdPublicacionParam, @IdZonaParam, @VigenciaDParam, @VigenciaHParam, @ValorParam, @Id_UsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdRecargoParam = actual.IdRecargo,
IdPublicacionParam = actual.IdPublicacion,
IdZonaParam = actual.IdZona,
VigenciaDParam = actual.VigenciaD,
VigenciaHParam = actual.VigenciaH,
ValorParam = actual.Valor,
Id_UsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Actualizado"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlUpdate, recargoAActualizar, transaction);
return rowsAffected == 1;
}
public async Task<bool> DeleteAsync(int idRecargo, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<RecargoZona>(
@"SELECT Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona,
VigenciaD, VigenciaH, Valor
FROM dbo.dist_RecargoZona WHERE Id_Recargo = @IdRecargoParam", new { IdRecargoParam = idRecargo }, transaction);
if (actual == null) throw new KeyNotFoundException("Recargo por zona no encontrado para eliminar.");
const string sqlDelete = "DELETE FROM dbo.dist_RecargoZona WHERE Id_Recargo = @IdRecargoParam"; // Usar parámetro con alias
const string sqlInsertHistorico = @"
INSERT INTO dbo.dist_RecargoZona_H (Id_Recargo, Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdRecargoParam, @IdPublicacionParam, @IdZonaParam, @VigenciaDParam, @VigenciaHParam, @ValorParam, @Id_UsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdRecargoParam = actual.IdRecargo,
IdPublicacionParam = actual.IdPublicacion,
IdZonaParam = actual.IdZona,
VigenciaDParam = actual.VigenciaD,
VigenciaHParam = actual.VigenciaH,
ValorParam = actual.Valor,
Id_UsuarioParam = idUsuario,
FechaModParam = DateTime.Now,
TipoModParam = "Eliminado"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdRecargoParam = idRecargo }, transaction);
return rowsAffected == 1;
}
public async Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction)
{
const string selectSql = @"
SELECT
Id_Recargo AS IdRecargo, Id_Publicacion AS IdPublicacion, Id_Zona AS IdZona,
VigenciaD, VigenciaH, Valor
FROM dbo.dist_RecargoZona WHERE Id_Publicacion = @IdPublicacionParam";
var itemsToDelete = await transaction.Connection!.QueryAsync<RecargoZona>(selectSql, new { IdPublicacionParam = idPublicacion }, transaction);
if (itemsToDelete.Any())
{
const string insertHistoricoSql = @"
INSERT INTO dbo.dist_RecargoZona_H (Id_Recargo, Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdRecargoParam, @IdPublicacionParam, @IdZonaParam, @VigenciaDParam, @VigenciaHParam, @ValorParam, @Id_UsuarioParam, @FechaModParam, @TipoModParam);";
foreach (var item in itemsToDelete)
{
await transaction.Connection!.ExecuteAsync(insertHistoricoSql, new
{
IdRecargoParam = item.IdRecargo,
IdPublicacionParam = item.IdPublicacion,
IdZonaParam = item.IdZona,
VigenciaDParam = item.VigenciaD,
VigenciaHParam = item.VigenciaH,
ValorParam = item.Valor,
Id_UsuarioParam = idUsuarioAuditoria,
FechaModParam = DateTime.Now,
TipoModParam = "Eliminado (Cascada)"
}, transaction);
}
}
const string deleteSql = "DELETE FROM dbo.dist_RecargoZona WHERE Id_Publicacion = @IdPublicacionParam";
try
{
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacionParam = idPublicacion }, transaction: transaction);
return true;
}
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
throw;
}
}
// Aquí irían otros métodos CRUD para RecargoZona si se gestionan individualmente.
// Por ejemplo, GetByPublicacionId, Create, Update, Delete (para un recargo específico).
}
}

144
Backend/GestionIntegral.Api/Data/Repositories/Distribucion/SalidaOtroDestinoRepository.cs Normal file
View File

@@ -0,0 +1,144 @@
using Dapper;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
using System;
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 SalidaOtroDestinoRepository : ISalidaOtroDestinoRepository
{
private readonly DbConnectionFactory _cf;
private readonly ILogger<SalidaOtroDestinoRepository> _log;
public SalidaOtroDestinoRepository(DbConnectionFactory cf, ILogger<SalidaOtroDestinoRepository> log)
{
_cf = cf;
_log = log;
}
public async Task<IEnumerable<SalidaOtroDestino>> GetAllAsync(DateTime? fechaDesde, DateTime? fechaHasta, int? idPublicacion, int? idDestino)
{
var sqlBuilder = new StringBuilder(@"
SELECT
Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Destino AS IdDestino,
Fecha, Cantidad, Observacion
FROM dbo.dist_SalidasOtrosDestinos
WHERE 1=1");
var parameters = new DynamicParameters();
if (fechaDesde.HasValue) { sqlBuilder.Append(" AND Fecha >= @FechaDesdeParam"); parameters.Add("FechaDesdeParam", fechaDesde.Value.Date); }
if (fechaHasta.HasValue) { sqlBuilder.Append(" AND Fecha <= @FechaHastaParam"); parameters.Add("FechaHastaParam", fechaHasta.Value.Date); }
if (idPublicacion.HasValue) { sqlBuilder.Append(" AND Id_Publicacion = @IdPublicacionParam"); parameters.Add("IdPublicacionParam", idPublicacion.Value); }
if (idDestino.HasValue) { sqlBuilder.Append(" AND Id_Destino = @IdDestinoParam"); parameters.Add("IdDestinoParam", idDestino.Value); }
sqlBuilder.Append(" ORDER BY Fecha DESC, Id_Publicacion;");
try
{
using var connection = _cf.CreateConnection();
return await connection.QueryAsync<SalidaOtroDestino>(sqlBuilder.ToString(), parameters);
}
catch (Exception ex)
{
_log.LogError(ex, "Error al obtener Salidas a Otros Destinos.");
return Enumerable.Empty<SalidaOtroDestino>();
}
}
public async Task<SalidaOtroDestino?> GetByIdAsync(int idParte)
{
const string sql = @"
SELECT
Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Destino AS IdDestino,
Fecha, Cantidad, Observacion
FROM dbo.dist_SalidasOtrosDestinos
WHERE Id_Parte = @IdParteParam";
try
{
using var connection = _cf.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<SalidaOtroDestino>(sql, new { IdParteParam = idParte });
}
catch (Exception ex)
{
_log.LogError(ex, "Error al obtener SalidaOtroDestino por ID: {IdParte}", idParte);
return null;
}
}
public async Task<SalidaOtroDestino?> CreateAsync(SalidaOtroDestino nuevaSalida, int idUsuario, IDbTransaction transaction)
{
const string sqlInsert = @"
INSERT INTO dbo.dist_SalidasOtrosDestinos (Id_Publicacion, Id_Destino, Fecha, Cantidad, Observacion)
OUTPUT INSERTED.Id_Parte AS IdParte, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Id_Destino AS IdDestino,
INSERTED.Fecha, INSERTED.Cantidad, INSERTED.Observacion
VALUES (@IdPublicacion, @IdDestino, @Fecha, @Cantidad, @Observacion);";
const string sqlHistorico = @"
INSERT INTO dbo.dist_SalidasOtrosDestinos_H (Id_Parte, Id_Publicacion, Id_Destino, Fecha, Cantidad, Observacion, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdParteHist, @IdPublicacionHist, @IdDestinoHist, @FechaHist, @CantidadHist, @ObservacionHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
var inserted = await transaction.Connection!.QuerySingleAsync<SalidaOtroDestino>(sqlInsert, nuevaSalida, transaction);
if (inserted == null || inserted.IdParte == 0) throw new DataException("Error al crear salida o ID no generado.");
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdParteHist = inserted.IdParte, IdPublicacionHist = inserted.IdPublicacion, IdDestinoHist = inserted.IdDestino,
FechaHist = inserted.Fecha, CantidadHist = inserted.Cantidad, ObservacionHist = inserted.Observacion,
IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Creada"
}, transaction);
return inserted;
}
public async Task<bool> UpdateAsync(SalidaOtroDestino salidaAActualizar, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<SalidaOtroDestino>(
@"SELECT Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Destino AS IdDestino, Fecha, Cantidad, Observacion
FROM dbo.dist_SalidasOtrosDestinos WHERE Id_Parte = @IdParteParam",
new { IdParteParam = salidaAActualizar.IdParte }, transaction);
if (actual == null) throw new KeyNotFoundException("Salida no encontrada.");
const string sqlUpdate = @"
UPDATE dbo.dist_SalidasOtrosDestinos SET
Cantidad = @Cantidad, Observacion = @Observacion
-- No se permite cambiar Publicacion, Destino o Fecha de una salida ya registrada
WHERE Id_Parte = @IdParte;";
const string sqlHistorico = @"
INSERT INTO dbo.dist_SalidasOtrosDestinos_H (Id_Parte, Id_Publicacion, Id_Destino, Fecha, Cantidad, Observacion, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdParteHist, @IdPublicacionHist, @IdDestinoHist, @FechaHist, @CantidadHist, @ObservacionHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdParteHist = actual.IdParte, IdPublicacionHist = actual.IdPublicacion, IdDestinoHist = actual.IdDestino,
FechaHist = actual.Fecha, CantidadHist = actual.Cantidad, ObservacionHist = actual.Observacion, // Valores ANTERIORES
IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Actualizada"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlUpdate, salidaAActualizar, transaction);
return rowsAffected == 1;
}
public async Task<bool> DeleteAsync(int idParte, int idUsuario, IDbTransaction transaction)
{
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<SalidaOtroDestino>(
@"SELECT Id_Parte AS IdParte, Id_Publicacion AS IdPublicacion, Id_Destino AS IdDestino, Fecha, Cantidad, Observacion
FROM dbo.dist_SalidasOtrosDestinos WHERE Id_Parte = @IdParteParam",
new { IdParteParam = idParte }, transaction);
if (actual == null) throw new KeyNotFoundException("Salida no encontrada para eliminar.");
const string sqlDelete = "DELETE FROM dbo.dist_SalidasOtrosDestinos WHERE Id_Parte = @IdParteParam";
const string sqlHistorico = @"
INSERT INTO dbo.dist_SalidasOtrosDestinos_H (Id_Parte, Id_Publicacion, Id_Destino, Fecha, Cantidad, Observacion, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdParteHist, @IdPublicacionHist, @IdDestinoHist, @FechaHist, @CantidadHist, @ObservacionHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdParteHist = actual.IdParte, IdPublicacionHist = actual.IdPublicacion, IdDestinoHist = actual.IdDestino,
FechaHist = actual.Fecha, CantidadHist = actual.Cantidad, ObservacionHist = actual.Observacion,
IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Eliminada"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdParteParam = idParte }, transaction);
return rowsAffected == 1;
}
}
}

27
Backend/GestionIntegral.Api/Data/Repositories/Impresion/IRegTiradaRepository.cs Normal file
View File

@@ -0,0 +1,27 @@
using GestionIntegral.Api.Models.Impresion;
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Data.Repositories.Impresion
{
public interface IRegTiradaRepository // Para bob_RegTiradas
{
Task<RegTirada?> GetByIdAsync(int idRegistro);
Task<IEnumerable<RegTirada>> GetByCriteriaAsync(DateTime? fecha, int? idPublicacion, int? idPlanta);
Task<RegTirada?> CreateAsync(RegTirada nuevaTirada, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteAsync(int idRegistro, int idUsuario, IDbTransaction transaction); // Si se borra el registro principal
Task<bool> DeleteByFechaPublicacionPlantaAsync(DateTime fecha, int idPublicacion, int idPlanta, int idUsuario, IDbTransaction transaction);
Task<RegTirada?> GetByFechaPublicacionPlantaAsync(DateTime fecha, int idPublicacion, int idPlanta, IDbTransaction? transaction = null);
}
public interface IRegPublicacionSeccionRepository // Para bob_RegPublicaciones
{
Task<IEnumerable<RegPublicacionSeccion>> GetByFechaPublicacionPlantaAsync(DateTime fecha, int idPublicacion, int idPlanta);
Task<RegPublicacionSeccion?> CreateAsync(RegPublicacionSeccion nuevaSeccionTirada, int idUsuario, IDbTransaction transaction);
Task<bool> DeleteByFechaPublicacionPlantaAsync(DateTime fecha, int idPublicacion, int idPlanta, int idUsuario, IDbTransaction transaction);
// Podría tener un DeleteByIdAsync si se permite borrar secciones individuales de una tirada
}
}

26
Backend/GestionIntegral.Api/Data/Repositories/Impresion/IStockBobinaRepository.cs Normal file
View File

@@ -0,0 +1,26 @@
using GestionIntegral.Api.Models.Impresion;
using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Data.Repositories.Distribucion
{
public interface IStockBobinaRepository
{
Task<IEnumerable<StockBobina>> GetAllAsync( // Para listados generales, DTO se arma en servicio
int? idTipoBobina,
string? nroBobinaFilter,
int? idPlanta,
int? idEstadoBobina,
string? remitoFilter,
DateTime? fechaDesde,
DateTime? fechaHasta);
Task<StockBobina?> GetByIdAsync(int idBobina);
Task<StockBobina?> GetByNroBobinaAsync(string nroBobina); // Para validar unicidad de NroBobina
Task<StockBobina?> CreateAsync(StockBobina nuevaBobina, int idUsuario, IDbTransaction transaction);
Task<bool> UpdateAsync(StockBobina bobinaAActualizar, int idUsuario, IDbTransaction transaction, string tipoMod = "Actualizada"); // tipoMod para historial
Task<bool> DeleteAsync(int idBobina, int idUsuario, IDbTransaction transaction); // Solo si está en estado "Disponible"
}
}

168
Backend/GestionIntegral.Api/Data/Repositories/Impresion/RegTiradaRepository.cs Normal file
View File

@@ -0,0 +1,168 @@
using Dapper;
using GestionIntegral.Api.Models.Impresion;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Data;
using System.Text;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Data.Repositories.Impresion
{
public class RegTiradaRepository : IRegTiradaRepository
{
private readonly DbConnectionFactory _cf;
private readonly ILogger<RegTiradaRepository> _log;
public RegTiradaRepository(DbConnectionFactory cf, ILogger<RegTiradaRepository> log)
{
_cf = cf;
_log = log;
}
public async Task<RegTirada?> GetByIdAsync(int idRegistro)
{
const string sql = "SELECT Id_Registro AS IdRegistro, Ejemplares, Id_Publicacion AS IdPublicacion, Fecha, Id_Planta AS IdPlanta FROM dbo.bob_RegTiradas WHERE Id_Registro = @IdRegistroParam";
using var connection = _cf.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<RegTirada>(sql, new { IdRegistroParam = idRegistro });
}
public async Task<RegTirada?> GetByFechaPublicacionPlantaAsync(DateTime fecha, int idPublicacion, int idPlanta, IDbTransaction? transaction = null)
{
const string sql = "SELECT Id_Registro AS IdRegistro, Ejemplares, Id_Publicacion AS IdPublicacion, Fecha, Id_Planta AS IdPlanta FROM dbo.bob_RegTiradas WHERE Fecha = @FechaParam AND Id_Publicacion = @IdPublicacionParam AND Id_Planta = @IdPlantaParam";
var cn = transaction?.Connection ?? _cf.CreateConnection();
bool ownConnection = transaction == null;
RegTirada? result = null;
try
{
if (ownConnection && cn.State == ConnectionState.Closed && cn is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync();
result = await cn.QuerySingleOrDefaultAsync<RegTirada>(sql, new { FechaParam = fecha.Date, IdPublicacionParam = idPublicacion, IdPlantaParam = idPlanta }, transaction);
}
finally
{
if (ownConnection && cn.State == ConnectionState.Open && cn is System.Data.Common.DbConnection dbConnClose) await dbConnClose.CloseAsync();
if (ownConnection) (cn as IDisposable)?.Dispose();
}
return result;
}
public async Task<IEnumerable<RegTirada>> GetByCriteriaAsync(DateTime? fecha, int? idPublicacion, int? idPlanta)
{
var sqlBuilder = new StringBuilder("SELECT Id_Registro AS IdRegistro, Ejemplares, Id_Publicacion AS IdPublicacion, Fecha, Id_Planta AS IdPlanta FROM dbo.bob_RegTiradas WHERE 1=1 ");
var parameters = new DynamicParameters();
if (fecha.HasValue) { sqlBuilder.Append("AND Fecha = @FechaParam "); parameters.Add("FechaParam", fecha.Value.Date); }
if (idPublicacion.HasValue) { sqlBuilder.Append("AND Id_Publicacion = @IdPublicacionParam "); parameters.Add("IdPublicacionParam", idPublicacion.Value); }
if (idPlanta.HasValue) { sqlBuilder.Append("AND Id_Planta = @IdPlantaParam "); parameters.Add("IdPlantaParam", idPlanta.Value); }
sqlBuilder.Append("ORDER BY Fecha DESC, Id_Publicacion;");
using var connection = _cf.CreateConnection();
return await connection.QueryAsync<RegTirada>(sqlBuilder.ToString(), parameters);
}
public async Task<RegTirada?> CreateAsync(RegTirada nuevaTirada, int idUsuario, IDbTransaction transaction)
{
const string sqlInsert = @"
INSERT INTO dbo.bob_RegTiradas (Ejemplares, Id_Publicacion, Fecha, Id_Planta)
OUTPUT INSERTED.Id_Registro AS IdRegistro, INSERTED.Ejemplares, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Fecha, INSERTED.Id_Planta AS IdPlanta
VALUES (@Ejemplares, @IdPublicacion, @Fecha, @IdPlanta);";
var inserted = await transaction.Connection!.QuerySingleAsync<RegTirada>(sqlInsert, nuevaTirada, transaction);
const string sqlHistorico = @"INSERT INTO dbo.bob_RegTiradas_H (Id_Registro, Ejemplares, Id_Publicacion, Fecha, Id_Planta, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdRegistroParam, @EjemplaresParam, @IdPublicacionParam, @FechaParam, @IdPlantaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdRegistroParam = inserted.IdRegistro, EjemplaresParam = inserted.Ejemplares, IdPublicacionParam = inserted.IdPublicacion, FechaParam = inserted.Fecha, IdPlantaParam = inserted.IdPlanta,
IdUsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModParam = "Creado"
}, transaction);
return inserted;
}
public async Task<bool> DeleteAsync(int idRegistro, int idUsuario, IDbTransaction transaction)
{
var actual = await GetByIdAsync(idRegistro); // No necesita TX aquí ya que es solo para historial
if (actual == null) throw new KeyNotFoundException("Registro de tirada no encontrado.");
const string sqlDelete = "DELETE FROM dbo.bob_RegTiradas WHERE Id_Registro = @IdRegistroParam";
const string sqlHistorico = @"INSERT INTO dbo.bob_RegTiradas_H (Id_Registro, Ejemplares, Id_Publicacion, Fecha, Id_Planta, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdRegistroParam, @EjemplaresParam, @IdPublicacionParam, @FechaParam, @IdPlantaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdRegistroParam = actual.IdRegistro, EjemplaresParam = actual.Ejemplares, IdPublicacionParam = actual.IdPublicacion, FechaParam = actual.Fecha, IdPlantaParam = actual.IdPlanta,
IdUsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModParam = "Eliminado"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdRegistroParam = idRegistro }, transaction);
return rowsAffected == 1;
}
public async Task<bool> DeleteByFechaPublicacionPlantaAsync(DateTime fecha, int idPublicacion, int idPlanta, int idUsuario, IDbTransaction transaction)
{
var tiradasAEliminar = await GetByCriteriaAsync(fecha.Date, idPublicacion, idPlanta); // Obtener antes de borrar para historial
foreach(var actual in tiradasAEliminar)
{
const string sqlHistorico = @"INSERT INTO dbo.bob_RegTiradas_H (Id_Registro, Ejemplares, Id_Publicacion, Fecha, Id_Planta, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdRegistroParam, @EjemplaresParam, @IdPublicacionParam, @FechaParam, @IdPlantaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdRegistroParam = actual.IdRegistro, EjemplaresParam = actual.Ejemplares, IdPublicacionParam = actual.IdPublicacion, FechaParam = actual.Fecha, IdPlantaParam = actual.IdPlanta,
IdUsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModParam = "Eliminado (Por Fecha/Pub/Planta)"
}, transaction);
}
const string sqlDelete = "DELETE FROM dbo.bob_RegTiradas WHERE Fecha = @FechaParam AND Id_Publicacion = @IdPublicacionParam AND Id_Planta = @IdPlantaParam";
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete,
new { FechaParam = fecha.Date, IdPublicacionParam = idPublicacion, IdPlantaParam = idPlanta }, transaction);
return rowsAffected > 0; // Devuelve true si se borró al menos una fila
}
}
public class RegPublicacionSeccionRepository : IRegPublicacionSeccionRepository
{
private readonly DbConnectionFactory _cf;
private readonly ILogger<RegPublicacionSeccionRepository> _log;
public RegPublicacionSeccionRepository(DbConnectionFactory cf, ILogger<RegPublicacionSeccionRepository> log){ _cf = cf; _log = log; }
public async Task<IEnumerable<RegPublicacionSeccion>> GetByFechaPublicacionPlantaAsync(DateTime fecha, int idPublicacion, int idPlanta)
{
const string sql = @"SELECT Id_Tirada AS IdTirada, Id_Publicacion AS IdPublicacion, Id_Seccion AS IdSeccion, CantPag, Fecha, Id_Planta AS IdPlanta
FROM dbo.bob_RegPublicaciones
WHERE Fecha = @FechaParam AND Id_Publicacion = @IdPublicacionParam AND Id_Planta = @IdPlantaParam";
using var connection = _cf.CreateConnection();
return await connection.QueryAsync<RegPublicacionSeccion>(sql, new { FechaParam = fecha.Date, IdPublicacionParam = idPublicacion, IdPlantaParam = idPlanta });
}
public async Task<RegPublicacionSeccion?> CreateAsync(RegPublicacionSeccion nuevaSeccionTirada, int idUsuario, IDbTransaction transaction)
{
const string sqlInsert = @"
INSERT INTO dbo.bob_RegPublicaciones (Id_Publicacion, Id_Seccion, CantPag, Fecha, Id_Planta)
OUTPUT INSERTED.Id_Tirada AS IdTirada, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Id_Seccion AS IdSeccion, INSERTED.CantPag, INSERTED.Fecha, INSERTED.Id_Planta AS IdPlanta
VALUES (@IdPublicacion, @IdSeccion, @CantPag, @Fecha, @IdPlanta);";
var inserted = await transaction.Connection!.QuerySingleAsync<RegPublicacionSeccion>(sqlInsert, nuevaSeccionTirada, transaction);
const string sqlHistorico = @"INSERT INTO dbo.bob_RegPublicaciones_H (Id_Tirada, Id_Publicacion, Id_Seccion, CantPag, Fecha, Id_Planta, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdTiradaParam, @IdPublicacionParam, @IdSeccionParam, @CantPagParam, @FechaParam, @IdPlantaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdTiradaParam = inserted.IdTirada, IdPublicacionParam = inserted.IdPublicacion, IdSeccionParam = inserted.IdSeccion, CantPagParam = inserted.CantPag, FechaParam = inserted.Fecha, IdPlantaParam = inserted.IdPlanta,
IdUsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModParam = "Creado"
}, transaction);
return inserted;
}
public async Task<bool> DeleteByFechaPublicacionPlantaAsync(DateTime fecha, int idPublicacion, int idPlanta, int idUsuario, IDbTransaction transaction)
{
var seccionesAEliminar = await GetByFechaPublicacionPlantaAsync(fecha.Date, idPublicacion, idPlanta); // No necesita TX, es SELECT
foreach(var actual in seccionesAEliminar)
{
const string sqlHistorico = @"INSERT INTO dbo.bob_RegPublicaciones_H (Id_Tirada, Id_Publicacion, Id_Seccion, CantPag, Fecha, Id_Planta, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdTiradaParam, @IdPublicacionParam, @IdSeccionParam, @CantPagParam, @FechaParam, @IdPlantaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
await transaction.Connection!.ExecuteAsync(sqlHistorico, new {
IdTiradaParam = actual.IdTirada, IdPublicacionParam = actual.IdPublicacion, IdSeccionParam = actual.IdSeccion, CantPagParam = actual.CantPag, FechaParam = actual.Fecha, IdPlantaParam = actual.IdPlanta,
IdUsuarioParam = idUsuario, FechaModParam = DateTime.Now, TipoModParam = "Eliminado (Por Fecha/Pub/Planta)"
}, transaction);
}
const string sqlDelete = "DELETE FROM dbo.bob_RegPublicaciones WHERE Fecha = @FechaParam AND Id_Publicacion = @IdPublicacionParam AND Id_Planta = @IdPlantaParam";
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete,
new { FechaParam = fecha.Date, IdPublicacionParam = idPublicacion, IdPlantaParam = idPlanta }, transaction);
return rowsAffected >= 0; // Devuelve true incluso si no había nada que borrar (para que no falle la TX si es parte de una cadena)
}
}
}

232
Backend/GestionIntegral.Api/Data/Repositories/Impresion/StockBobinaRepository.cs Normal file
View File

@@ -0,0 +1,232 @@
using Dapper;
using GestionIntegral.Api.Models.Impresion;
using Microsoft.Extensions.Logging;
using System;
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 StockBobinaRepository : IStockBobinaRepository
{
private readonly DbConnectionFactory _connectionFactory;
private readonly ILogger<StockBobinaRepository> _logger;
public StockBobinaRepository(DbConnectionFactory connectionFactory, ILogger<StockBobinaRepository> logger)
{
_connectionFactory = connectionFactory;
_logger = logger;
}
public async Task<IEnumerable<StockBobina>> GetAllAsync(
int? idTipoBobina, string? nroBobinaFilter, int? idPlanta,
int? idEstadoBobina, string? remitoFilter, DateTime? fechaDesde, DateTime? fechaHasta)
{
var sqlBuilder = new StringBuilder(@"
SELECT
sb.Id_Bobina AS IdBobina, sb.Id_TipoBobina AS IdTipoBobina, sb.NroBobina, sb.Peso,
sb.Id_Planta AS IdPlanta, sb.Id_EstadoBobina AS IdEstadoBobina, sb.Remito, sb.FechaRemito,
sb.FechaEstado, sb.Id_Publicacion AS IdPublicacion, sb.Id_Seccion AS IdSeccion, sb.Obs
FROM dbo.bob_StockBobinas sb
WHERE 1=1");
var parameters = new DynamicParameters();
if (idTipoBobina.HasValue)
{
sqlBuilder.Append(" AND sb.Id_TipoBobina = @IdTipoBobinaParam");
parameters.Add("IdTipoBobinaParam", idTipoBobina.Value);
}
if (!string.IsNullOrWhiteSpace(nroBobinaFilter))
{
sqlBuilder.Append(" AND sb.NroBobina LIKE @NroBobinaParam");
parameters.Add("NroBobinaParam", $"%{nroBobinaFilter}%");
}
if (idPlanta.HasValue)
{
sqlBuilder.Append(" AND sb.Id_Planta = @IdPlantaParam");
parameters.Add("IdPlantaParam", idPlanta.Value);
}
if (idEstadoBobina.HasValue)
{
sqlBuilder.Append(" AND sb.Id_EstadoBobina = @IdEstadoBobinaParam");
parameters.Add("IdEstadoBobinaParam", idEstadoBobina.Value);
}
if (!string.IsNullOrWhiteSpace(remitoFilter))
{
sqlBuilder.Append(" AND sb.Remito LIKE @RemitoParam");
parameters.Add("RemitoParam", $"%{remitoFilter}%");
}
if (fechaDesde.HasValue)
{
sqlBuilder.Append(" AND sb.FechaRemito >= @FechaDesdeParam"); // O FechaEstado según el contexto del filtro
parameters.Add("FechaDesdeParam", fechaDesde.Value.Date);
}
if (fechaHasta.HasValue)
{
sqlBuilder.Append(" AND sb.FechaRemito <= @FechaHastaParam"); // O FechaEstado
parameters.Add("FechaHastaParam", fechaHasta.Value.Date.AddDays(1).AddTicks(-1)); // Hasta el final del día
}
sqlBuilder.Append(" ORDER BY sb.FechaRemito DESC, sb.NroBobina;");
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.QueryAsync<StockBobina>(sqlBuilder.ToString(), parameters);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener Stock de Bobinas con filtros.");
return Enumerable.Empty<StockBobina>();
}
}
public async Task<StockBobina?> GetByIdAsync(int idBobina)
{
const string sql = @"
SELECT
Id_Bobina AS IdBobina, Id_TipoBobina AS IdTipoBobina, NroBobina, Peso,
Id_Planta AS IdPlanta, Id_EstadoBobina AS IdEstadoBobina, Remito, FechaRemito,
FechaEstado, Id_Publicacion AS IdPublicacion, Id_Seccion AS IdSeccion, Obs
FROM dbo.bob_StockBobinas
WHERE Id_Bobina = @IdBobinaParam";
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<StockBobina>(sql, new { IdBobinaParam = idBobina });
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener StockBobina por ID: {IdBobina}", idBobina);
return null;
}
}
public async Task<StockBobina?> GetByNroBobinaAsync(string nroBobina)
{
const string sql = @"
SELECT
Id_Bobina AS IdBobina, Id_TipoBobina AS IdTipoBobina, NroBobina, Peso,
Id_Planta AS IdPlanta, Id_EstadoBobina AS IdEstadoBobina, Remito, FechaRemito,
FechaEstado, Id_Publicacion AS IdPublicacion, Id_Seccion AS IdSeccion, Obs
FROM dbo.bob_StockBobinas
WHERE NroBobina = @NroBobinaParam";
try
{
using var connection = _connectionFactory.CreateConnection();
return await connection.QuerySingleOrDefaultAsync<StockBobina>(sql, new { NroBobinaParam = nroBobina });
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener StockBobina por NroBobina: {NroBobina}", nroBobina);
return null;
}
}
public async Task<StockBobina?> CreateAsync(StockBobina nuevaBobina, int idUsuario, IDbTransaction transaction)
{
const string sqlInsert = @"
INSERT INTO dbo.bob_StockBobinas
(Id_TipoBobina, NroBobina, Peso, Id_Planta, Id_EstadoBobina, Remito, FechaRemito, FechaEstado, Id_Publicacion, Id_Seccion, Obs)
OUTPUT INSERTED.Id_Bobina AS IdBobina, INSERTED.Id_TipoBobina AS IdTipoBobina, INSERTED.NroBobina, INSERTED.Peso,
INSERTED.Id_Planta AS IdPlanta, INSERTED.Id_EstadoBobina AS IdEstadoBobina, INSERTED.Remito, INSERTED.FechaRemito,
INSERTED.FechaEstado, INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Id_Seccion AS IdSeccion, INSERTED.Obs
VALUES (@IdTipoBobina, @NroBobina, @Peso, @IdPlanta, @IdEstadoBobina, @Remito, @FechaRemito, @FechaEstado, @IdPublicacion, @IdSeccion, @Obs);";
var inserted = await transaction.Connection!.QuerySingleAsync<StockBobina>(sqlInsert, nuevaBobina, transaction);
if (inserted == null || inserted.IdBobina == 0) throw new DataException("Error al ingresar bobina o ID no generado.");
const string sqlInsertHistorico = @"
INSERT INTO dbo.bob_StockBobinas_H
(Id_Bobina, Id_TipoBobina, NroBobina, Peso, Id_Planta, Id_EstadoBobina, Remito, FechaRemito, FechaEstado, Id_Publicacion, Id_Seccion, Obs, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdBobinaHist, @IdTipoBobinaHist, @NroBobinaHist, @PesoHist, @IdPlantaHist, @IdEstadoBobinaHist, @RemitoHist, @FechaRemitoHist, @FechaEstadoHist, @IdPublicacionHist, @IdSeccionHist, @ObsHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdBobinaHist = inserted.IdBobina, IdTipoBobinaHist = inserted.IdTipoBobina, NroBobinaHist = inserted.NroBobina, PesoHist = inserted.Peso,
IdPlantaHist = inserted.IdPlanta, IdEstadoBobinaHist = inserted.IdEstadoBobina, RemitoHist = inserted.Remito, FechaRemitoHist = inserted.FechaRemito,
FechaEstadoHist = inserted.FechaEstado, IdPublicacionHist = inserted.IdPublicacion, IdSeccionHist = inserted.IdSeccion, ObsHist = inserted.Obs,
IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Ingreso"
}, transaction);
return inserted;
}
public async Task<bool> UpdateAsync(StockBobina bobinaAActualizar, int idUsuario, IDbTransaction transaction, string tipoMod = "Actualizada")
{
// Obtener estado actual para el historial
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<StockBobina>(
@"SELECT Id_Bobina AS IdBobina, Id_TipoBobina AS IdTipoBobina, NroBobina, Peso,
Id_Planta AS IdPlanta, Id_EstadoBobina AS IdEstadoBobina, Remito, FechaRemito,
FechaEstado, Id_Publicacion AS IdPublicacion, Id_Seccion AS IdSeccion, Obs
FROM dbo.bob_StockBobinas WHERE Id_Bobina = @IdBobinaParam",
new { IdBobinaParam = bobinaAActualizar.IdBobina }, transaction);
if (actual == null) throw new KeyNotFoundException("Bobina no encontrada para actualizar.");
const string sqlUpdate = @"
UPDATE dbo.bob_StockBobinas SET
Id_TipoBobina = @IdTipoBobina, NroBobina = @NroBobina, Peso = @Peso, Id_Planta = @IdPlanta,
Id_EstadoBobina = @IdEstadoBobina, Remito = @Remito, FechaRemito = @FechaRemito, FechaEstado = @FechaEstado,
Id_Publicacion = @IdPublicacion, Id_Seccion = @IdSeccion, Obs = @Obs
WHERE Id_Bobina = @IdBobina;";
const string sqlInsertHistorico = @"
INSERT INTO dbo.bob_StockBobinas_H
(Id_Bobina, Id_TipoBobina, NroBobina, Peso, Id_Planta, Id_EstadoBobina, Remito, FechaRemito, FechaEstado, Id_Publicacion, Id_Seccion, Obs, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdBobinaHist, @IdTipoBobinaHist, @NroBobinaHist, @PesoHist, @IdPlantaHist, @IdEstadoBobinaHist, @RemitoHist, @FechaRemitoHist, @FechaEstadoHist, @IdPublicacionHist, @IdSeccionHist, @ObsHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdBobinaHist = actual.IdBobina, IdTipoBobinaHist = actual.IdTipoBobina, NroBobinaHist = actual.NroBobina, PesoHist = actual.Peso,
IdPlantaHist = actual.IdPlanta, IdEstadoBobinaHist = actual.IdEstadoBobina, RemitoHist = actual.Remito, FechaRemitoHist = actual.FechaRemito,
FechaEstadoHist = actual.FechaEstado, IdPublicacionHist = actual.IdPublicacion, IdSeccionHist = actual.IdSeccion, ObsHist = actual.Obs,
IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = tipoMod // "Actualizada" o "Estado Cambiado"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlUpdate, bobinaAActualizar, transaction);
return rowsAffected == 1;
}
public async Task<bool> DeleteAsync(int idBobina, int idUsuario, IDbTransaction transaction)
{
// Normalmente, una bobina en stock no se "elimina" físicamente si ya tuvo movimientos.
// Este método sería para borrar un ingreso erróneo que aún esté "Disponible".
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<StockBobina>(
@"SELECT Id_Bobina AS IdBobina, Id_TipoBobina AS IdTipoBobina, NroBobina, Peso,
Id_Planta AS IdPlanta, Id_EstadoBobina AS IdEstadoBobina, Remito, FechaRemito,
FechaEstado, Id_Publicacion AS IdPublicacion, Id_Seccion AS IdSeccion, Obs
FROM dbo.bob_StockBobinas WHERE Id_Bobina = @IdBobinaParam",
new { IdBobinaParam = idBobina }, transaction);
if (actual == null) throw new KeyNotFoundException("Bobina no encontrada para eliminar.");
// VALIDACIÓN IMPORTANTE: Solo permitir borrar si está en estado "Disponible" (o el que se defina)
if (actual.IdEstadoBobina != 1) // Asumiendo 1 = Disponible
{
_logger.LogWarning("Intento de eliminar bobina {IdBobina} que no está en estado 'Disponible'. Estado actual: {EstadoActual}", idBobina, actual.IdEstadoBobina);
// No lanzar excepción para que la transacción no falle si es una validación de negocio
return false;
}
const string sqlDelete = "DELETE FROM dbo.bob_StockBobinas WHERE Id_Bobina = @IdBobinaParam";
const string sqlInsertHistorico = @"
INSERT INTO dbo.bob_StockBobinas_H
(Id_Bobina, Id_TipoBobina, NroBobina, Peso, Id_Planta, Id_EstadoBobina, Remito, FechaRemito, FechaEstado, Id_Publicacion, Id_Seccion, Obs, Id_Usuario, FechaMod, TipoMod)
VALUES (@IdBobinaHist, @IdTipoBobinaHist, @NroBobinaHist, @PesoHist, @IdPlantaHist, @IdEstadoBobinaHist, @RemitoHist, @FechaRemitoHist, @FechaEstadoHist, @IdPublicacionHist, @IdSeccionHist, @ObsHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
{
IdBobinaHist = actual.IdBobina, IdTipoBobinaHist = actual.IdTipoBobina, NroBobinaHist = actual.NroBobina, PesoHist = actual.Peso,
IdPlantaHist = actual.IdPlanta, IdEstadoBobinaHist = actual.IdEstadoBobina, RemitoHist = actual.Remito, FechaRemitoHist = actual.FechaRemito,
FechaEstadoHist = actual.FechaEstado, IdPublicacionHist = actual.IdPublicacion, IdSeccionHist = actual.IdSeccion, ObsHist = actual.Obs,
IdUsuarioHist = idUsuario, FechaModHist = DateTime.Now, TipoModHist = "Eliminada"
}, transaction);
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdBobinaParam = idBobina }, transaction);
return rowsAffected == 1;
}
}
}