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

Backend:

Browse Source 
Diseño de un AuditoriaController con un patrón para añadir endpoints de historial para diferentes entidades.
Implementación de la lógica de servicio y repositorio para obtener datos de las tablas _H para:
Usuarios (gral_Usuarios_H)
Pagos de Distribuidores (cue_PagosDistribuidor_H)
Notas de Crédito/Débito (cue_CreditosDebitos_H)
Entradas/Salidas de Distribuidores (dist_EntradasSalidas_H)
Entradas/Salidas de Canillitas (dist_EntradasSalidasCanillas_H)
Novedades de Canillitas (dist_dtNovedadesCanillas_H)
Ajustes Manuales de Saldo (cue_SaldoAjustesHistorial)
Tipos de Pago (cue_dtTipopago_H)
Canillitas (Maestro) (dist_dtCanillas_H)
Distribuidores (Maestro) (dist_dtDistribuidores_H)
Empresas (Maestro) (dist_dtEmpresas_H)
DTOs específicos para cada tipo de historial, incluyendo NombreUsuarioModifico.
Frontend:
Servicio auditoriaService.ts con métodos para llamar a cada endpoint de historial.
Página AuditoriaGeneralPage.tsx con:
Selector de "Tipo de Entidad a Auditar".
Filtros comunes (Fechas, Usuario Modificador, Tipo de Modificación, ID Entidad).
Un DataGrid que muestra las columnas dinámicamente según el tipo de entidad seleccionada.
Lógica para cargar los datos correspondientes.
DTOs de historial en TypeScript.
Actualizaciones en AppRoutes.tsx y MainLayout.tsx para la nueva sección de Auditoría (restringida a SuperAdmin).
This commit is contained in:
eldiadmolinari
2025-06-09 19:37:07 -03:00
parent 35e24ab7d2
commit 437b1e8864
98 changed files with 3683 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

185
Backend/GestionIntegral.Api/Services/Distribucion/CambioParadaService.cs Normal file
View File

@@ -0,0 +1,185 @@
using GestionIntegral.Api.Data;
using GestionIntegral.Api.Data.Repositories.Distribucion;
using GestionIntegral.Api.Dtos.Distribucion;
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.Services.Distribucion
{
public class CambioParadaService : ICambioParadaService
{
private readonly ICambioParadaRepository _paradaRepo;
private readonly ICanillaRepository _canillaRepo; // Para nombre y validación
private readonly DbConnectionFactory _connectionFactory;
private readonly ILogger<CambioParadaService> _logger;
public CambioParadaService(
ICambioParadaRepository paradaRepo,
ICanillaRepository canillaRepo,
DbConnectionFactory connectionFactory,
ILogger<CambioParadaService> logger)
{
_paradaRepo = paradaRepo;
_canillaRepo = canillaRepo;
_connectionFactory = connectionFactory;
_logger = logger;
}
private async Task<CambioParadaDto> MapToDto(CambioParadaCanilla parada)
{
var canillaData = await _canillaRepo.GetByIdAsync(parada.IdCanilla);
return new CambioParadaDto
{
IdRegistro = parada.IdRegistro,
IdCanilla = parada.IdCanilla,
NombreCanilla = canillaData.Canilla?.NomApe ?? "N/A",
Parada = parada.Parada,
VigenciaD = parada.VigenciaD.ToString("yyyy-MM-dd"),
VigenciaH = parada.VigenciaH?.ToString("yyyy-MM-dd")
};
}
public async Task<IEnumerable<CambioParadaDto>> ObtenerPorCanillaAsync(int idCanilla)
{
var paradas = await _paradaRepo.GetByCanillaAsync(idCanilla);
var dtos = new List<CambioParadaDto>();
foreach (var p in paradas) { dtos.Add(await MapToDto(p)); }
return dtos;
}
public async Task<CambioParadaDto?> ObtenerPorIdAsync(int idRegistro)
{
var parada = await _paradaRepo.GetByIdAsync(idRegistro);
return parada == null ? null : await MapToDto(parada);
}
public async Task<(CambioParadaDto? Parada, string? Error)> CrearNuevaParadaAsync(int idCanilla, CreateCambioParadaDto createDto, int idUsuario)
{
var canilla = await _canillaRepo.GetByIdSimpleAsync(idCanilla);
if (canilla == null) return (null, "Canillita no encontrado.");
if (createDto.VigenciaD.Date < DateTime.Today.AddYears(-5) || createDto.VigenciaD.Date > DateTime.Today.AddYears(5)) // Validación básica de fecha
return (null, "Fecha de Vigencia Desde inválida.");
using var connection = _connectionFactory.CreateConnection();
if (connection.State != ConnectionState.Open) { if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open(); }
using var transaction = connection.BeginTransaction();
try
{
// 1. Buscar la parada activa actual (si existe) para cerrarla
var paradaActual = await _paradaRepo.GetCurrentParadaAsync(idCanilla, transaction);
if (paradaActual != null)
{
if (createDto.VigenciaD.Date <= paradaActual.VigenciaD.Date)
{
transaction.Rollback();
return (null, "La Vigencia Desde de la nueva parada debe ser posterior a la Vigencia Desde de la parada activa actual.");
}
// Cerrar la parada actual estableciendo VigenciaH al día anterior de la nueva VigenciaD
DateTime vigenciaHAactual = createDto.VigenciaD.Date.AddDays(-1);
bool cerrada = await _paradaRepo.UpdateVigenciaHAsync(paradaActual.IdRegistro, vigenciaHAactual, idUsuario, transaction);
if (!cerrada) throw new DataException("No se pudo cerrar la parada activa anterior.");
_logger.LogInformation("Parada anterior ID {IdRegistro} cerrada con VigenciaH {VigenciaH}", paradaActual.IdRegistro, vigenciaHAactual);
}
// 2. Crear la nueva parada
var nuevaParada = new CambioParadaCanilla
{
IdCanilla = idCanilla,
Parada = createDto.Parada,
VigenciaD = createDto.VigenciaD.Date,
VigenciaH = null // Nueva parada siempre inicia activa
};
var paradaCreada = await _paradaRepo.CreateAsync(nuevaParada, idUsuario, transaction);
if (paradaCreada == null) throw new DataException("Error al crear el nuevo registro de parada.");
// 3. Actualizar la parada principal en dist_dtCanillas
canilla.Parada = paradaCreada.Parada; // Actualizar el campo Parada en la tabla principal
bool canillaActualizado = await _canillaRepo.UpdateAsync(canilla, idUsuario, transaction); // Asume que tu repo de canilla tiene UpdateAsync que toma la entidad
if (!canillaActualizado) throw new DataException("Error al actualizar la parada principal del canillita.");
transaction.Commit();
_logger.LogInformation("Nueva parada ID {IdRegistro} creada para Canilla ID {IdCanilla}. Parada principal actualizada.", paradaCreada.IdRegistro, idCanilla);
return (await MapToDto(paradaCreada), null);
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch { }
_logger.LogError(ex, "Error en CrearNuevaParadaAsync para Canilla ID {IdCanilla}", idCanilla);
return (null, $"Error interno: {ex.Message}");
}
finally { if (connection.State == ConnectionState.Open) { if (connection is System.Data.Common.DbConnection dbConn) await dbConn.CloseAsync(); else connection.Close(); } }
}
public async Task<(bool Exito, string? Error)> CerrarParadaAsync(int idRegistro, UpdateCambioParadaDto updateDto, int idUsuario)
{
// Este método es para cerrar una parada manualmente si es necesario,
// por ejemplo, si se cometió un error y no se creó una nueva que la cierre.
var paradaExistente = await _paradaRepo.GetByIdAsync(idRegistro);
if (paradaExistente == null) return (false, "Registro de parada no encontrado.");
if (paradaExistente.VigenciaH.HasValue) return (false, "Esta parada ya tiene una fecha de Vigencia Hasta.");
if (updateDto.VigenciaH.Date < paradaExistente.VigenciaD.Date)
return (false, "La Vigencia Hasta no puede ser anterior a la Vigencia Desde.");
using var connection = _connectionFactory.CreateConnection();
if (connection.State != ConnectionState.Open) { if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open(); }
using var transaction = connection.BeginTransaction();
try
{
bool actualizada = await _paradaRepo.UpdateVigenciaHAsync(idRegistro, updateDto.VigenciaH.Date, idUsuario, transaction);
if (!actualizada) throw new DataException("Error al actualizar la Vigencia Hasta de la parada.");
// Opcional: Si esta era la parada activa en dist_dtCanillas, podrías querer limpiarla o marcarla de alguna forma
// Esto depende de si el campo 'Parada' en dist_dtCanillas siempre debe reflejar la última activa.
// Por simplicidad, no se actualiza dist_dtCanillas aquí al cerrar una parada manualmente.
transaction.Commit();
_logger.LogInformation("VigenciaH actualizada para Parada ID {IdRegistro}", idRegistro);
return (true, null);
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch { }
_logger.LogError(ex, "Error al cerrar Parada ID {IdRegistro}", idRegistro);
return (false, $"Error interno: {ex.Message}");
}
finally { if (connection.State == ConnectionState.Open) { if (connection is System.Data.Common.DbConnection dbConn) await dbConn.CloseAsync(); else connection.Close(); } }
}
public async Task<(bool Exito, string? Error)> EliminarParadaAsync(int idRegistro, int idUsuario)
{
// La eliminación puede ser problemática si rompe la secuencia histórica.
// Considera si realmente quieres permitir esto o solo "cerrar" paradas.
var paradaExistente = await _paradaRepo.GetByIdAsync(idRegistro);
if (paradaExistente == null) return (false, "Registro de parada no encontrado.");
if (paradaExistente.VigenciaH == null)
return (false, "No se puede eliminar una parada activa. Primero debe cerrarla o crear una nueva que la reemplace.");
using var connection = _connectionFactory.CreateConnection();
if (connection.State != ConnectionState.Open) { if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open(); }
using var transaction = connection.BeginTransaction();
try
{
bool eliminado = await _paradaRepo.DeleteAsync(idRegistro, idUsuario, transaction);
if (!eliminado) throw new DataException("Error al eliminar el registro de parada.");
transaction.Commit();
_logger.LogInformation("Registro de Parada ID {IdRegistro} eliminado por Usuario ID {IdUsuario}", idRegistro, idUsuario);
return (true, null);
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch { }
_logger.LogError(ex, "Error al eliminar Parada ID {IdRegistro}", idRegistro);
return (false, $"Error interno: {ex.Message}");
}
finally { if (connection.State == ConnectionState.Open) { if (connection is System.Data.Common.DbConnection dbConn) await dbConn.CloseAsync(); else connection.Close(); } }
}
}
}

27
Backend/GestionIntegral.Api/Services/Distribucion/CanillaService.cs
View File

@@ -1,5 +1,6 @@
using GestionIntegral.Api.Data;
using GestionIntegral.Api.Data.Repositories.Distribucion;
using GestionIntegral.Api.Dtos.Auditoria;
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
@@ -261,5 +262,31 @@ namespace GestionIntegral.Api.Services.Distribucion
return (false, $"Error interno al cambiar estado de baja: {ex.Message}");
}
}
public async Task<IEnumerable<CanillaHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idCanillaAfectado)
{
var historialData = await _canillaRepository.GetHistorialAsync(fechaDesde, fechaHasta, idUsuarioModifico, tipoModificacion, idCanillaAfectado);
return historialData.Select(h => new CanillaHistorialDto
{
Id_Canilla = h.Historial.Id_Canilla,
Legajo = h.Historial.Legajo,
NomApe = h.Historial.NomApe,
Parada = h.Historial.Parada,
Id_Zona = h.Historial.Id_Zona,
Accionista = h.Historial.Accionista,
Obs = h.Historial.Obs,
Empresa = h.Historial.Empresa,
Baja = h.Historial.Baja,
FechaBaja = h.Historial.FechaBaja,
Id_Usuario = h.Historial.Id_Usuario,
NombreUsuarioModifico = h.NombreUsuarioModifico,
FechaMod = h.Historial.FechaMod,
TipoMod = h.Historial.TipoMod
}).ToList();
}
}
}

58
Backend/GestionIntegral.Api/Services/Distribucion/DistribuidorService.cs
View File

@@ -2,6 +2,7 @@
using GestionIntegral.Api.Data;
using GestionIntegral.Api.Data.Repositories.Contables;
using GestionIntegral.Api.Data.Repositories.Distribucion;
using GestionIntegral.Api.Dtos.Auditoria;
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
@@ -85,7 +86,7 @@ namespace GestionIntegral.Api.Services.Distribucion
var data = await _distribuidorRepository.GetByIdAsync(id);
// MapToDto ahora devuelve DistribuidorDto?
return MapToDto(data);
}
}
public async Task<DistribuidorLookupDto?> ObtenerLookupPorIdAsync(int id)
{
@@ -104,9 +105,17 @@ namespace GestionIntegral.Api.Services.Distribucion
var nuevoDistribuidor = new Distribuidor
{
Nombre = createDto.Nombre, Contacto = createDto.Contacto, NroDoc = createDto.NroDoc, IdZona = createDto.IdZona,
Calle = createDto.Calle, Numero = createDto.Numero, Piso = createDto.Piso, Depto = createDto.Depto,
Telefono = createDto.Telefono, Email = createDto.Email, Localidad = createDto.Localidad
Nombre = createDto.Nombre,
Contacto = createDto.Contacto,
NroDoc = createDto.NroDoc,
IdZona = createDto.IdZona,
Calle = createDto.Calle,
Numero = createDto.Numero,
Piso = createDto.Piso,
Depto = createDto.Depto,
Telefono = createDto.Telefono,
Email = createDto.Email,
Localidad = createDto.Localidad
};
using var connection = _connectionFactory.CreateConnection();
@@ -136,7 +145,7 @@ namespace GestionIntegral.Api.Services.Distribucion
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch {}
try { transaction.Rollback(); } catch { }
_logger.LogError(ex, "Error CrearAsync Distribuidor: {Nombre}", createDto.Nombre);
return (null, $"Error interno al crear el distribuidor: {ex.Message}");
}
@@ -173,10 +182,10 @@ namespace GestionIntegral.Api.Services.Distribucion
_logger.LogInformation("Distribuidor ID {IdDistribuidor} actualizado por Usuario ID {IdUsuario}.", id, idUsuario);
return (true, null);
}
catch (KeyNotFoundException) { try { transaction.Rollback(); } catch {} return (false, "Distribuidor no encontrado."); }
catch (KeyNotFoundException) { try { transaction.Rollback(); } catch { } return (false, "Distribuidor no encontrado."); }
catch (Exception ex)
{
try { transaction.Rollback(); } catch {}
try { transaction.Rollback(); } catch { }
_logger.LogError(ex, "Error ActualizarAsync Distribuidor ID: {IdDistribuidor}", id);
return (false, $"Error interno: {ex.Message}");
}
@@ -200,18 +209,47 @@ namespace GestionIntegral.Api.Services.Distribucion
// if (!saldosEliminados) throw new DataException("Error al eliminar saldos del distribuidor.");
var eliminado = await _distribuidorRepository.DeleteAsync(id, idUsuario, transaction);
if (!eliminado) throw new DataException("Error al eliminar.");
if (!eliminado) throw new DataException("Error al eliminar.");
transaction.Commit();
_logger.LogInformation("Distribuidor ID {IdDistribuidor} eliminado por Usuario ID {IdUsuario}.", id, idUsuario);
return (true, null);
}
catch (KeyNotFoundException) { try { transaction.Rollback(); } catch {} return (false, "Distribuidor no encontrado."); }
catch (KeyNotFoundException) { try { transaction.Rollback(); } catch { } return (false, "Distribuidor no encontrado."); }
catch (Exception ex)
{
try { transaction.Rollback(); } catch {}
try { transaction.Rollback(); } catch { }
_logger.LogError(ex, "Error EliminarAsync Distribuidor ID: {IdDistribuidor}", id);
return (false, $"Error interno: {ex.Message}");
}
}
public async Task<IEnumerable<DistribuidorHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idDistribuidorAfectado)
{
var historialData = await _distribuidorRepository.GetHistorialAsync(fechaDesde, fechaHasta, idUsuarioModifico, tipoModificacion, idDistribuidorAfectado);
// Si necesitas NombreZona, harías el JOIN en el repo o una llamada aquí a _zonaRepository
return historialData.Select(h => new DistribuidorHistorialDto
{
Id_Distribuidor = h.Historial.Id_Distribuidor,
Nombre = h.Historial.Nombre,
Contacto = h.Historial.Contacto,
NroDoc = h.Historial.NroDoc,
Id_Zona = h.Historial.Id_Zona,
Calle = h.Historial.Calle,
Numero = h.Historial.Numero,
Piso = h.Historial.Piso,
Depto = h.Historial.Depto,
Telefono = h.Historial.Telefono,
Email = h.Historial.Email,
Localidad = h.Historial.Localidad,
Id_Usuario = h.Historial.Id_Usuario,
NombreUsuarioModifico = h.NombreUsuarioModifico,
FechaMod = h.Historial.FechaMod,
TipoMod = h.Historial.TipoMod
}).ToList();
}
}
}

115
Backend/GestionIntegral.Api/Services/Distribucion/EmpresaService.cs
View File

@@ -7,7 +7,8 @@ using System.Data;
using GestionIntegral.Api.Data;
using GestionIntegral.Api.Models.Distribucion;
using GestionIntegral.Api.Data.Repositories.Distribucion;
using GestionIntegral.Api.Data.Repositories.Contables; // Para IDbTransaction, ConnectionState
using GestionIntegral.Api.Data.Repositories.Contables;
using GestionIntegral.Api.Dtos.Auditoria; // Para IDbTransaction, ConnectionState
namespace GestionIntegral.Api.Services.Distribucion
{
@@ -42,7 +43,7 @@ namespace GestionIntegral.Api.Services.Distribucion
Detalle = e.Detalle
});
}
public async Task<IEnumerable<EmpresaDropdownDto>> ObtenerParaDropdown()
{
// El repositorio ya devuelve solo las activas si es necesario
@@ -131,7 +132,7 @@ namespace GestionIntegral.Api.Services.Distribucion
{
throw new InvalidOperationException($"Falló al crear saldo inicial para distribuidor {idDistribuidor} y nueva empresa {empresaCreada.IdEmpresa}.");
}
_logger.LogInformation("Saldo inicial creado para Distribuidor ID {IdDistribuidor}, Empresa ID {IdEmpresa}", idDistribuidor, empresaCreada.IdEmpresa);
_logger.LogInformation("Saldo inicial creado para Distribuidor ID {IdDistribuidor}, Empresa ID {IdEmpresa}", idDistribuidor, empresaCreada.IdEmpresa);
}
transaction.Commit();
@@ -158,41 +159,41 @@ namespace GestionIntegral.Api.Services.Distribucion
public async Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdateEmpresaDto updateDto, int idUsuario)
{
var empresaExistente = await _empresaRepository.GetByIdAsync(id);
if (empresaExistente == null)
{
return (false, "Empresa no encontrada.");
}
var empresaExistente = await _empresaRepository.GetByIdAsync(id);
if (empresaExistente == null)
{
return (false, "Empresa no encontrada.");
}
if (await _empresaRepository.ExistsByNameAsync(updateDto.Nombre, id))
{
return (false, "El nombre de la empresa ya existe para otro registro.");
}
if (await _empresaRepository.ExistsByNameAsync(updateDto.Nombre, id))
{
return (false, "El nombre de la empresa ya existe para otro registro.");
}
empresaExistente.Nombre = updateDto.Nombre;
empresaExistente.Detalle = updateDto.Detalle;
empresaExistente.Nombre = updateDto.Nombre;
empresaExistente.Detalle = updateDto.Detalle;
// --- Transacción ---
using (var connection = _connectionFactory.CreateConnection())
{
if (connection is System.Data.Common.DbConnection dbConnection) { await dbConnection.OpenAsync(); } else { connection.Open(); }
using (var transaction = connection.BeginTransaction())
if (connection is System.Data.Common.DbConnection dbConnection) { await dbConnection.OpenAsync(); } else { connection.Open(); }
using (var transaction = connection.BeginTransaction())
{
try
{
var actualizado = await _empresaRepository.UpdateAsync(empresaExistente, idUsuario, transaction);
if (!actualizado)
{
throw new InvalidOperationException("La actualización en el repositorio de empresas devolvió false.");
}
transaction.Commit();
_logger.LogInformation("Empresa ID {IdEmpresa} actualizada exitosamente por Usuario ID {IdUsuario}.", id, idUsuario);
return (true, null); // Éxito
var actualizado = await _empresaRepository.UpdateAsync(empresaExistente, idUsuario, transaction);
if (!actualizado)
{
throw new InvalidOperationException("La actualización en el repositorio de empresas devolvió false.");
}
transaction.Commit();
_logger.LogInformation("Empresa ID {IdEmpresa} actualizada exitosamente por Usuario ID {IdUsuario}.", id, idUsuario);
return (true, null); // Éxito
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error al intentar hacer rollback en ActualizarAsync Empresa."); }
_logger.LogError(ex, "Error en transacción ActualizarAsync para Empresa ID: {Id}", id);
_logger.LogError(ex, "Error en transacción ActualizarAsync para Empresa ID: {Id}", id);
return (false, "Error interno al actualizar la empresa.");
}
}
@@ -215,35 +216,39 @@ namespace GestionIntegral.Api.Services.Distribucion
return (false, "No se puede eliminar. Existen publicaciones relacionadas a la empresa.");
}
// --- Transacción ---
// --- Transacción ---
using (var connection = _connectionFactory.CreateConnection())
{
if (connection is System.Data.Common.DbConnection dbConnection) { await dbConnection.OpenAsync(); } else { connection.Open(); }
using (var transaction = connection.BeginTransaction())
if (connection is System.Data.Common.DbConnection dbConnection) { await dbConnection.OpenAsync(); } else { connection.Open(); }
using (var transaction = connection.BeginTransaction())
{
try
{
// 1. Eliminar Saldos asociados
bool saldosEliminados = await _saldoRepository.DeleteSaldosByEmpresaAsync(id, transaction);
// No lanzamos error si saldosEliminados es false, podría no haber tenido saldos. Loggeamos si es necesario.
if (!saldosEliminados && await _saldoRepository.CheckIfSaldosExistForEmpresaAsync(id)) // Necesitarías este método en ISaldoRepository
{
_logger.LogWarning("Se intentó eliminar Empresa ID {IdEmpresa} pero falló la eliminación de saldos asociados.", id);
// Decidir si continuar o fallar. Por ahora, continuamos pero loggeamos.
// throw new InvalidOperationException("Error al intentar eliminar los saldos asociados a la empresa.");
} else if (!saldosEliminados) {
_logger.LogInformation("No se encontraron saldos para eliminar de la Empresa ID {IdEmpresa}.", id);
} else {
_logger.LogInformation("Saldos eliminados para Empresa ID {IdEmpresa}.", id);
}
if (!saldosEliminados && await _saldoRepository.CheckIfSaldosExistForEmpresaAsync(id)) // Necesitarías este método en ISaldoRepository
{
_logger.LogWarning("Se intentó eliminar Empresa ID {IdEmpresa} pero falló la eliminación de saldos asociados.", id);
// Decidir si continuar o fallar. Por ahora, continuamos pero loggeamos.
// throw new InvalidOperationException("Error al intentar eliminar los saldos asociados a la empresa.");
}
else if (!saldosEliminados)
{
_logger.LogInformation("No se encontraron saldos para eliminar de la Empresa ID {IdEmpresa}.", id);
}
else
{
_logger.LogInformation("Saldos eliminados para Empresa ID {IdEmpresa}.", id);
}
// 2. Eliminar Empresa (Repo maneja historial)
var eliminado = await _empresaRepository.DeleteAsync(id, idUsuario, transaction);
if (!eliminado)
{
throw new InvalidOperationException("La eliminación en el repositorio de empresas devolvió false.");
}
var eliminado = await _empresaRepository.DeleteAsync(id, idUsuario, transaction);
if (!eliminado)
{
throw new InvalidOperationException("La eliminación en el repositorio de empresas devolvió false.");
}
transaction.Commit();
_logger.LogInformation("Empresa ID {IdEmpresa} eliminada exitosamente por Usuario ID {IdUsuario}.", id, idUsuario);
@@ -252,12 +257,30 @@ namespace GestionIntegral.Api.Services.Distribucion
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error al intentar hacer rollback en EliminarAsync Empresa."); }
_logger.LogError(ex, "Error en transacción EliminarAsync para Empresa ID: {Id}", id);
_logger.LogError(ex, "Error en transacción EliminarAsync para Empresa ID: {Id}", id);
return (false, "Error interno al eliminar la empresa.");
}
}
}
// --- Fin Transacción ---
}
}
public async Task<IEnumerable<EmpresaHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idEmpresaAfectada)
{
var historialData = await _empresaRepository.GetHistorialAsync(fechaDesde, fechaHasta, idUsuarioModifico, tipoModificacion, idEmpresaAfectada);
return historialData.Select(h => new EmpresaHistorialDto
{
Id_Empresa = h.Historial.Id_Empresa,
Nombre = h.Historial.Nombre,
Detalle = h.Historial.Detalle,
Id_Usuario = h.Historial.Id_Usuario,
NombreUsuarioModifico = h.NombreUsuarioModifico,
FechaMod = h.Historial.FechaMod,
TipoMod = h.Historial.TipoMod
}).ToList();
}
}
}

28
Backend/GestionIntegral.Api/Services/Distribucion/EntradaSalidaCanillaService.cs
View File

@@ -11,6 +11,7 @@ using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using System.Security.Claims;
using GestionIntegral.Api.Dtos.Auditoria;
namespace GestionIntegral.Api.Services.Distribucion
{
@@ -476,5 +477,32 @@ namespace GestionIntegral.Api.Services.Distribucion
}
}
}
public async Task<IEnumerable<EntradaSalidaCanillaHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idParteAfectada)
{
// Asumiendo que _esCanillaRepository es tu IEntradaSalidaCanillaRepository
var historialData = await _esCanillaRepository.GetHistorialAsync(fechaDesde, fechaHasta, idUsuarioModifico, tipoModificacion, idParteAfectada);
return historialData.Select(h => new EntradaSalidaCanillaHistorialDto
{
Id_Parte = h.Historial.Id_Parte,
Id_Publicacion = h.Historial.Id_Publicacion,
Id_Canilla = h.Historial.Id_Canilla,
Fecha = h.Historial.Fecha,
CantSalida = h.Historial.CantSalida,
CantEntrada = h.Historial.CantEntrada,
Id_Precio = h.Historial.Id_Precio,
Id_Recargo = h.Historial.Id_Recargo,
Id_PorcMon = h.Historial.Id_PorcMon,
Observacion = h.Historial.Observacion,
Id_Usuario = h.Historial.Id_Usuario,
NombreUsuarioModifico = h.NombreUsuarioModifico,
FechaMod = h.Historial.FechaMod,
TipoMod = h.Historial.TipoMod
}).ToList();
}
}
}

100
Backend/GestionIntegral.Api/Services/Distribucion/EntradaSalidaDistService.cs
View File

@@ -1,6 +1,7 @@
using GestionIntegral.Api.Data;
using GestionIntegral.Api.Data.Repositories.Contables;
using GestionIntegral.Api.Data.Repositories.Distribucion;
using GestionIntegral.Api.Dtos.Auditoria;
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Models.Distribucion;
using Microsoft.Extensions.Logging;
@@ -56,30 +57,15 @@ namespace GestionIntegral.Api.Services.Distribucion
var publicacionData = await _publicacionRepository.GetByIdAsync(es.IdPublicacion);
var distribuidorData = await _distribuidorRepository.GetByIdAsync(es.IdDistribuidor);
// Obtener el valor bruto del movimiento
decimal valorBrutoMovimiento = await CalcularMontoMovimiento(
es.IdPublicacion, es.IdDistribuidor, es.Fecha, es.Cantidad,
es.IdPublicacion, es.IdDistribuidor, es.Fecha, es.Cantidad,
es.TipoMovimiento, // Pasamos el tipo de movimiento original aquí
es.IdPrecio, es.IdRecargo, es.IdPorcentaje, distribuidorData.Distribuidor?.IdZona
);
// Ajustar para el DTO: si es "Entrada", el monto calculado es un crédito (negativo o positivo según convención)
// Para consistencia con el ajuste de saldo, si es Entrada, el MontoCalculado para el DTO puede ser el valor
// que se le "acredita" al distribuidor (o sea, el valor de la mercadería devuelta).
// La lógica de +/- para el saldo ya está en Crear/Actualizar/Eliminar.
// Aquí solo mostramos el valor del movimiento. Si es entrada, es el valor de lo devuelto.
// Si es salida, es el valor de lo que se le factura.
// El método CalcularMonto ya devuelve el monto que el distribuidor DEBE pagar por una SALIDA.
// Para una ENTRADA (devolución), el valor de esa mercadería es el mismo, pero opera en sentido contrario al saldo.
decimal montoCalculadoParaDto = valorBrutoMovimiento;
// Si queremos que el DTO muestre las entradas como un valor que "reduce la deuda",
// podría ser positivo. Si queremos que refleje el impacto directo en la factura (salidas suman, entradas restan),
// podríamos hacerlo negativo.
// Por ahora, dejaremos que CalcularMontoMovimiento devuelva el valor de una "Salida",
// y si es "Entrada", este mismo valor es el que se acredita.
// La columna `MontoCalculado` en el DTO representará el valor de la transacción.
return new EntradaSalidaDistDto
{
@@ -98,13 +84,10 @@ namespace GestionIntegral.Api.Services.Distribucion
MontoCalculado = montoCalculadoParaDto // Representa el valor de los N ejemplares
};
}
private async Task<decimal> CalcularMontoMovimiento(int idPublicacion, int idDistribuidor, DateTime fecha, int cantidad, string tipoMovimiento,
int idPrecio, int idRecargo, int idPorcentaje, int? idZonaDistribuidor)
{
// YA NO SE DEVUELVE 0 PARA ENTRADA AQUÍ
// if (tipoMovimiento == "Entrada") return 0;
var precioConfig = await _precioRepository.GetByIdAsync(idPrecio);
// Es crucial que idPrecio sea válido y se haya determinado correctamente antes de llamar aquí.
// Si precioConfig es null, se lanzará una excepción abajo, lo cual está bien si es un estado inesperado.
@@ -118,7 +101,6 @@ namespace GestionIntegral.Api.Services.Distribucion
throw new InvalidOperationException($"Configuración de precio ID {idPrecio} no encontrada. No se puede calcular el monto.");
}
decimal precioDia = 0;
DayOfWeek diaSemana = fecha.DayOfWeek;
switch (diaSemana)
@@ -135,13 +117,13 @@ namespace GestionIntegral.Api.Services.Distribucion
decimal valorRecargo = 0;
if (idRecargo > 0 && idZonaDistribuidor.HasValue)
{
var recargoConfig = await _recargoZonaRepository.GetActiveByPublicacionZonaAndDateAsync(idPublicacion, idZonaDistribuidor.Value, fecha);
var recargoConfig = await _recargoZonaRepository.GetActiveByPublicacionZonaAndDateAsync(idPublicacion, idZonaDistribuidor.Value, fecha);
if (recargoConfig != null)
{
valorRecargo = recargoConfig.Valor;
}
}
decimal precioConRecargo = precioDia + valorRecargo;
decimal montoBase = precioConRecargo * cantidad;
@@ -197,7 +179,7 @@ namespace GestionIntegral.Api.Services.Distribucion
RecargoZona? recargoActivo = null;
if (distribuidor.IdZona.HasValue)
{
recargoActivo = await _recargoZonaRepository.GetActiveByPublicacionZonaAndDateAsync(createDto.IdPublicacion, distribuidor.IdZona.Value, createDto.Fecha.Date);
recargoActivo = await _recargoZonaRepository.GetActiveByPublicacionZonaAndDateAsync(createDto.IdPublicacion, distribuidor.IdZona.Value, createDto.Fecha.Date);
}
var porcPagoActivo = await _porcPagoRepository.GetActiveByPublicacionDistribuidorAndDateAsync(createDto.IdPublicacion, createDto.IdDistribuidor, createDto.Fecha.Date);
@@ -228,13 +210,13 @@ namespace GestionIntegral.Api.Services.Distribucion
decimal montoAfectacion = await CalcularMontoMovimiento(
esCreada.IdPublicacion, esCreada.IdDistribuidor, esCreada.Fecha, esCreada.Cantidad, esCreada.TipoMovimiento,
esCreada.IdPrecio, esCreada.IdRecargo, esCreada.IdPorcentaje, distribuidor.IdZona);
// Si es Salida, montoAfectacion es positivo (aumenta deuda). Si es Entrada, es 0 por CalcularMontoMovimiento,
// pero para el saldo, una Entrada (devolución) debería restar del saldo deudor.
// Por lo tanto, el monto real a restar del saldo si es Entrada sería el valor de esos ejemplares devueltos.
if(esCreada.TipoMovimiento == "Entrada")
if (esCreada.TipoMovimiento == "Entrada")
{
// Recalcular como si fuera salida para obtener el valor a acreditar/restar del saldo
// Recalcular como si fuera salida para obtener el valor a acreditar/restar del saldo
montoAfectacion = await CalcularMontoMovimiento(
esCreada.IdPublicacion, esCreada.IdDistribuidor, esCreada.Fecha, esCreada.Cantidad, "Salida", // Forzar tipo Salida para cálculo de valor
esCreada.IdPrecio, esCreada.IdRecargo, esCreada.IdPorcentaje, distribuidor.IdZona);
@@ -259,12 +241,12 @@ namespace GestionIntegral.Api.Services.Distribucion
public async Task<(bool Exito, string? Error)> ActualizarMovimientoAsync(int idParte, UpdateEntradaSalidaDistDto updateDto, int idUsuario)
{
// La actualización de un movimiento que afecta saldos es compleja.
// Si cambia la cantidad, el monto original y el nuevo deben calcularse,
// y la diferencia debe aplicarse al saldo.
// Por ahora, este DTO solo permite cambiar Cantidad y Observacion.
// Cambiar otros campos como Fecha, Publicacion, Distribuidor implicaría recalcular todo
// y posiblemente anular el movimiento original y crear uno nuevo.
// La actualización de un movimiento que afecta saldos es compleja.
// Si cambia la cantidad, el monto original y el nuevo deben calcularse,
// y la diferencia debe aplicarse al saldo.
// Por ahora, este DTO solo permite cambiar Cantidad y Observacion.
// Cambiar otros campos como Fecha, Publicacion, Distribuidor implicaría recalcular todo
// y posiblemente anular el movimiento original y crear uno nuevo.
using var connection = _connectionFactory.CreateConnection();
if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open();
@@ -275,16 +257,16 @@ namespace GestionIntegral.Api.Services.Distribucion
if (esExistente == null) return (false, "Movimiento no encontrado.");
var publicacion = await _publicacionRepository.GetByIdSimpleAsync(esExistente.IdPublicacion);
if (publicacion == null) return (false, "Publicación asociada no encontrada."); // Muy raro
if (publicacion == null) return (false, "Publicación asociada no encontrada."); // Muy raro
var distribuidor = await _distribuidorRepository.GetByIdSimpleAsync(esExistente.IdDistribuidor);
if (distribuidor == null) return (false, "Distribuidor asociado no encontrado.");
if (distribuidor == null) return (false, "Distribuidor asociado no encontrado.");
// 1. Calcular monto del movimiento original (antes de la actualización)
decimal montoOriginal = await CalcularMontoMovimiento(
esExistente.IdPublicacion, esExistente.IdDistribuidor, esExistente.Fecha, esExistente.Cantidad, esExistente.TipoMovimiento,
esExistente.IdPrecio, esExistente.IdRecargo, esExistente.IdPorcentaje, distribuidor.IdZona);
if(esExistente.TipoMovimiento == "Entrada") montoOriginal *= -1; // Para revertir
if (esExistente.TipoMovimiento == "Entrada") montoOriginal *= -1; // Para revertir
// 2. Actualizar la entidad en la BD (esto también guarda en historial)
var esParaActualizar = new EntradaSalidaDist
@@ -308,7 +290,7 @@ namespace GestionIntegral.Api.Services.Distribucion
decimal montoNuevo = await CalcularMontoMovimiento(
esParaActualizar.IdPublicacion, esParaActualizar.IdDistribuidor, esParaActualizar.Fecha, esParaActualizar.Cantidad, esParaActualizar.TipoMovimiento,
esParaActualizar.IdPrecio, esParaActualizar.IdRecargo, esParaActualizar.IdPorcentaje, distribuidor.IdZona);
if(esParaActualizar.TipoMovimiento == "Entrada") montoNuevo *= -1;
if (esParaActualizar.TipoMovimiento == "Entrada") montoNuevo *= -1;
// 4. Ajustar saldo con la diferencia
@@ -351,16 +333,19 @@ namespace GestionIntegral.Api.Services.Distribucion
decimal montoReversion = await CalcularMontoMovimiento(
esExistente.IdPublicacion, esExistente.IdDistribuidor, esExistente.Fecha, esExistente.Cantidad, esExistente.TipoMovimiento,
esExistente.IdPrecio, esExistente.IdRecargo, esExistente.IdPorcentaje, distribuidor.IdZona);
// Si es Salida, el monto es positivo, al revertir restamos.
// Si es Entrada, el monto es 0 (por Calcular...), pero su efecto en saldo fue negativo, al revertir sumamos el valor.
if(esExistente.TipoMovimiento == "Salida") {
if (esExistente.TipoMovimiento == "Salida")
{
montoReversion *= -1; // Para restar del saldo lo que se sumó
} else if (esExistente.TipoMovimiento == "Entrada") {
}
else if (esExistente.TipoMovimiento == "Entrada")
{
// Recalcular el valor como si fuera salida para saber cuánto se restó del saldo
montoReversion = await CalcularMontoMovimiento(
esExistente.IdPublicacion, esExistente.IdDistribuidor, esExistente.Fecha, esExistente.Cantidad, "Salida",
esExistente.IdPrecio, esExistente.IdRecargo, esExistente.IdPorcentaje, distribuidor.IdZona);
montoReversion = await CalcularMontoMovimiento(
esExistente.IdPublicacion, esExistente.IdDistribuidor, esExistente.Fecha, esExistente.Cantidad, "Salida",
esExistente.IdPrecio, esExistente.IdRecargo, esExistente.IdPorcentaje, distribuidor.IdZona);
// No se multiplica por -1 aquí, porque el saldo ya lo tiene restado, al eliminar revertimos sumando.
}
@@ -385,5 +370,32 @@ namespace GestionIntegral.Api.Services.Distribucion
return (false, $"Error interno: {ex.Message}");
}
}
public async Task<IEnumerable<EntradaSalidaDistHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idParteAfectada)
{
var historialData = await _esRepository.GetHistorialAsync(fechaDesde, fechaHasta, idUsuarioModifico, tipoModificacion, idParteAfectada);
return historialData.Select(h => new EntradaSalidaDistHistorialDto
{
Id_Parte = h.Historial.Id_Parte,
Id_Publicacion = h.Historial.Id_Publicacion,
Id_Distribuidor = h.Historial.Id_Distribuidor,
Fecha = h.Historial.Fecha,
TipoMovimiento = h.Historial.TipoMovimiento,
Cantidad = h.Historial.Cantidad,
Remito = h.Historial.Remito,
Observacion = h.Historial.Observacion,
Id_Precio = h.Historial.Id_Precio,
Id_Recargo = h.Historial.Id_Recargo,
Id_Porcentaje = h.Historial.Id_Porcentaje,
Id_Usuario = h.Historial.Id_Usuario,
NombreUsuarioModifico = h.NombreUsuarioModifico,
FechaMod = h.Historial.FechaMod,
TipoMod = h.Historial.TipoMod
}).ToList();
}
}
}

17
Backend/GestionIntegral.Api/Services/Distribucion/ICambioParadaService.cs Normal file
View File

@@ -0,0 +1,17 @@
using GestionIntegral.Api.Dtos.Distribucion;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Services.Distribucion
{
public interface ICambioParadaService
{
Task<IEnumerable<CambioParadaDto>> ObtenerPorCanillaAsync(int idCanilla);
Task<CambioParadaDto?> ObtenerPorIdAsync(int idRegistro);
Task<(CambioParadaDto? Parada, string? Error)> CrearNuevaParadaAsync(int idCanilla, CreateCambioParadaDto createDto, int idUsuario);
// Update podría ser solo para cerrar la vigencia, no para cambiar la dirección de una parada histórica.
Task<(bool Exito, string? Error)> CerrarParadaAsync(int idRegistro, UpdateCambioParadaDto updateDto, int idUsuario);
Task<(bool Exito, string? Error)> EliminarParadaAsync(int idRegistro, int idUsuario); // Si se permite
}
}

5
Backend/GestionIntegral.Api/Services/Distribucion/ICanillaService.cs
View File

@@ -1,3 +1,4 @@
using GestionIntegral.Api.Dtos.Auditoria;
using GestionIntegral.Api.Dtos.Distribucion;
using System.Collections.Generic;
using System.Threading.Tasks;
@@ -11,5 +12,9 @@ namespace GestionIntegral.Api.Services.Distribucion
Task<(CanillaDto? Canilla, string? Error)> CrearAsync(CreateCanillaDto createDto, int idUsuario);
Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdateCanillaDto updateDto, int idUsuario);
Task<(bool Exito, string? Error)> ToggleBajaAsync(int id, bool darDeBaja, int idUsuario);
Task<IEnumerable<CanillaHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idCanillaAfectado);
}
}

5
Backend/GestionIntegral.Api/Services/Distribucion/IDistribuidorService.cs
View File

@@ -1,3 +1,4 @@
using GestionIntegral.Api.Dtos.Auditoria;
using GestionIntegral.Api.Dtos.Distribucion;
using System.Collections.Generic;
using System.Threading.Tasks;
@@ -13,5 +14,9 @@ namespace GestionIntegral.Api.Services.Distribucion
Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario);
Task<IEnumerable<DistribuidorDropdownDto>> GetAllDropdownAsync();
Task<DistribuidorLookupDto?> ObtenerLookupPorIdAsync(int id);
Task<IEnumerable<DistribuidorHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idDistribuidorAfectado);
}
}

5
Backend/GestionIntegral.Api/Services/Distribucion/IEmpresaService.cs
View File

@@ -1,4 +1,5 @@
using GestionIntegral.Api.Dtos.Empresas; // DTOs de Empresas
using GestionIntegral.Api.Dtos.Auditoria;
using System.Collections.Generic;
using System.Threading.Tasks;
@@ -13,5 +14,9 @@ namespace GestionIntegral.Api.Services.Distribucion
Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario);
Task<IEnumerable<EmpresaDropdownDto>> ObtenerParaDropdown();
Task<EmpresaLookupDto?> ObtenerLookupPorIdAsync(int id);
Task<IEnumerable<EmpresaHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idEmpresaAfectada);
}
}

5
Backend/GestionIntegral.Api/Services/Distribucion/IEntradaSalidaCanillaService.cs
View File

@@ -1,3 +1,4 @@
using GestionIntegral.Api.Dtos.Auditoria;
using GestionIntegral.Api.Dtos.Distribucion;
using System;
using System.Collections.Generic;
@@ -19,5 +20,9 @@ namespace GestionIntegral.Api.Services.Distribucion
Task<(bool Exito, string? Error)> EliminarMovimientoAsync(int idParte, int idUsuario, ClaimsPrincipal userPrincipal);
Task<(bool Exito, string? Error)> LiquidarMovimientosAsync(LiquidarMovimientosCanillaRequestDto liquidarDto, int idUsuarioLiquidador);
Task<IEnumerable<EntradaSalidaCanillaHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idParteAfectada);
}
}

5
Backend/GestionIntegral.Api/Services/Distribucion/IEntradaSalidaDistService.cs
View File

@@ -1,3 +1,4 @@
using GestionIntegral.Api.Dtos.Auditoria;
using GestionIntegral.Api.Dtos.Distribucion;
using System;
using System.Collections.Generic;
@@ -12,5 +13,9 @@ namespace GestionIntegral.Api.Services.Distribucion
Task<(EntradaSalidaDistDto? Movimiento, string? Error)> CrearMovimientoAsync(CreateEntradaSalidaDistDto createDto, int idUsuario);
Task<(bool Exito, string? Error)> ActualizarMovimientoAsync(int idParte, UpdateEntradaSalidaDistDto updateDto, int idUsuario);
Task<(bool Exito, string? Error)> EliminarMovimientoAsync(int idParte, int idUsuario);
Task<IEnumerable<EntradaSalidaDistHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idParteAfectada);
}
}

5
Backend/GestionIntegral.Api/Services/Distribucion/INovedadCanillaService.cs
View File

@@ -1,3 +1,4 @@
using GestionIntegral.Api.Dtos.Auditoria;
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Dtos.Reportes;
using System;
@@ -15,5 +16,9 @@ namespace GestionIntegral.Api.Services.Distribucion
Task<(bool Exito, string? Error)> EliminarAsync(int idNovedad, int idUsuario);
Task<IEnumerable<NovedadesCanillasReporteDto>> ObtenerReporteNovedadesAsync(int idEmpresa, DateTime fechaDesde, DateTime fechaHasta);
Task<IEnumerable<CanillaGananciaReporteDto>> ObtenerReporteGananciasAsync(int idEmpresa, DateTime fechaDesde, DateTime fechaHasta);
Task<IEnumerable<NovedadCanillaHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idNovedadAfectada);
}
}

22
Backend/GestionIntegral.Api/Services/Distribucion/NovedadCanillaService.cs
View File

@@ -1,6 +1,7 @@
// En Services/Distribucion (o donde corresponda)
using GestionIntegral.Api.Data; // Para DbConnectionFactory
using GestionIntegral.Api.Data.Repositories.Distribucion;
using GestionIntegral.Api.Dtos.Auditoria;
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Dtos.Reportes;
using GestionIntegral.Api.Models.Distribucion; // Asegúrate que el modelo Canilla tenga NomApe
@@ -250,5 +251,26 @@ namespace GestionIntegral.Api.Services.Distribucion
throw;
}
}
public async Task<IEnumerable<NovedadCanillaHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idNovedadAfectada)
{
var historialData = await _novedadRepository.GetHistorialAsync(fechaDesde, fechaHasta, idUsuarioModifico, tipoModificacion, idNovedadAfectada);
return historialData.Select(h => new NovedadCanillaHistorialDto
{
Id_Novedad = h.Historial.Id_Novedad,
Id_Canilla = h.Historial.Id_Canilla,
Fecha = h.Historial.Fecha,
Detalle = h.Historial.Detalle,
Id_Usuario = h.Historial.Id_Usuario,
NombreUsuarioModifico = h.NombreUsuarioModifico,
FechaMod = h.Historial.FechaMod,
TipoMod = h.Historial.TipoMod
// Si decides traer NombreCanilla desde el repo, mapealo aquí.
}).ToList();
}
}
}