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

1. Funcionalidad Principal: Auditoría General

Browse Source 
Se creó una nueva sección de "Auditoría" en la aplicación, diseñada para ser accedida por SuperAdmins.
Se implementó una página AuditoriaGeneralPage.tsx que actúa como un visor centralizado para el historial de cambios de múltiples entidades del sistema.
2. Backend:
Nuevo Controlador (AuditoriaController.cs): Centraliza los endpoints para obtener datos de las tablas de historial (_H).
Servicios y Repositorios Extendidos:
Se añadieron métodos GetHistorialAsync y ObtenerHistorialAsync a las capas de repositorio y servicio para cada una de las siguientes entidades, permitiendo consultar sus tablas _H con filtros:
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)
Tipos de Pago (cue_dtTipopago_H)
Canillitas (Maestro) (dist_dtCanillas_H)
Distribuidores (Maestro) (dist_dtDistribuidores_H)
Empresas (Maestro) (dist_dtEmpresas_H)
Zonas (Maestro) (dist_dtZonas_H)
Otros Destinos (Maestro) (dist_dtOtrosDestinos_H)
Publicaciones (Maestro) (dist_dtPublicaciones_H)
Secciones de Publicación (dist_dtPubliSecciones_H)
Precios de Publicación (dist_Precios_H)
Recargos por Zona (dist_RecargoZona_H)
Porcentajes Pago Distribuidores (dist_PorcPago_H)
Porcentajes/Montos Canillita (dist_PorcMonPagoCanilla_H)
Control de Devoluciones (dist_dtCtrlDevoluciones_H)
Tipos de Bobina (bob_dtBobinas_H)
Estados de Bobina (bob_dtEstadosBobinas_H)
Plantas de Impresión (bob_dtPlantas_H)
Stock de Bobinas (bob_StockBobinas_H)
Tiradas (Registro Principal) (bob_RegTiradas_H)
Secciones de Tirada (bob_RegPublicaciones_H)
Cambios de Parada de Canillitas (dist_CambiosParadasCanillas_H)
Ajustes Manuales de Saldo (cue_SaldoAjustesHistorial)
DTOs de Historial: Se crearon DTOs específicos para cada tabla de historial (ej. UsuarioHistorialDto, PagoDistribuidorHistorialDto, etc.) para transferir los datos al frontend, incluyendo el nombre del usuario que realizó la modificación.
Corrección de Lógica de Saldos: Se revisó y corrigió la lógica de afectación de saldos en los servicios PagoDistribuidorService y NotaCreditoDebitoService para asegurar que los débitos y créditos se apliquen correctamente.
3. Frontend:
Nuevo Servicio (auditoriaService.ts): Contiene métodos para llamar a cada uno de los nuevos endpoints de auditoría del backend.
Nueva Página (AuditoriaGeneralPage.tsx):
Permite al SuperAdmin seleccionar el "Tipo de Entidad" a auditar desde un dropdown.
Ofrece filtros comunes (rango de fechas, usuario modificador, tipo de acción) y filtros específicos que aparecen dinámicamente según la entidad seleccionada.
Utiliza un DataGrid de Material-UI para mostrar el historial, con columnas que se adaptan dinámicamente al tipo de entidad consultada.
Nuevos DTOs en TypeScript: Se crearon las interfaces correspondientes a los DTOs de historial del backend.
Gestión de Permisos:
La sección de Auditoría en MainLayout.tsx y su ruta en AppRoutes.tsx están protegidas para ser visibles y accesibles solo por SuperAdmins.
Se añadió un permiso de ejemplo AU_GENERAL_VIEW para ser usado si se decide extender el acceso en el futuro.
Corrección de Errores Menores: Se solucionó el problema del "parpadeo" del selector de fecha en GestionarNovedadesCanillaPage al adoptar un patrón de carga de datos más controlado, similar a otras páginas funcionales.
This commit is contained in:
eldiadmolinari
2025-06-12 19:36:21 -03:00
parent 437b1e8864
commit b04a3b99bf
145 changed files with 5033 additions and 1070 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
Backend/GestionIntegral.Api/Services/Distribucion/PrecioService.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;
@@ -37,8 +38,13 @@ namespace GestionIntegral.Api.Services.Distribucion
IdPublicacion = precio.IdPublicacion,
VigenciaD = precio.VigenciaD.ToString("yyyy-MM-dd"),
VigenciaH = precio.VigenciaH?.ToString("yyyy-MM-dd"),
Lunes = precio.Lunes, Martes = precio.Martes, Miercoles = precio.Miercoles,
Jueves = precio.Jueves, Viernes = precio.Viernes, Sabado = precio.Sabado, Domingo = precio.Domingo
Lunes = precio.Lunes,
Martes = precio.Martes,
Miercoles = precio.Miercoles,
Jueves = precio.Jueves,
Viernes = precio.Viernes,
Sabado = precio.Sabado,
Domingo = precio.Domingo
};
public async Task<IEnumerable<PrecioDto>> ObtenerPorPublicacionIdAsync(int idPublicacion)
@@ -73,8 +79,13 @@ namespace GestionIntegral.Api.Services.Distribucion
IdPublicacion = createDto.IdPublicacion,
VigenciaD = createDto.VigenciaD.Date, // Asegurar que solo sea fecha
VigenciaH = null, // Se establece al crear el siguiente o al cerrar manualmente
Lunes = createDto.Lunes ?? 0, Martes = createDto.Martes ?? 0, Miercoles = createDto.Miercoles ?? 0,
Jueves = createDto.Jueves ?? 0, Viernes = createDto.Viernes ?? 0, Sabado = createDto.Sabado ?? 0, Domingo = createDto.Domingo ?? 0
Lunes = createDto.Lunes ?? 0,
Martes = createDto.Martes ?? 0,
Miercoles = createDto.Miercoles ?? 0,
Jueves = createDto.Jueves ?? 0,
Viernes = createDto.Viernes ?? 0,
Sabado = createDto.Sabado ?? 0,
Domingo = createDto.Domingo ?? 0
};
using var connection = _connectionFactory.CreateConnection();
@@ -99,7 +110,7 @@ namespace GestionIntegral.Api.Services.Distribucion
{
throw new DataException("No se pudo cerrar el período de precio anterior.");
}
_logger.LogInformation("Precio anterior ID {IdPrecioAnterior} cerrado con VigenciaH {VigenciaH}.", precioAnterior.IdPrecio, precioAnterior.VigenciaH);
_logger.LogInformation("Precio anterior ID {IdPrecioAnterior} cerrado con VigenciaH {VigenciaH}.", precioAnterior.IdPrecio, precioAnterior.VigenciaH);
}
// 3. Crear el nuevo registro de precio
@@ -126,91 +137,150 @@ namespace GestionIntegral.Api.Services.Distribucion
try
{
var precioExistente = await _precioRepository.GetByIdAsync(idPrecio); // Obtener dentro de la TX por si acaso
if (precioExistente == null) return (false, "Período de precio no encontrado.");
// En una actualización, principalmente actualizamos los montos de los días.
// VigenciaH se puede actualizar para cerrar un período explícitamente.
// No se permite cambiar IdPublicacion ni VigenciaD aquí.
// Si VigenciaH se establece, debe ser >= VigenciaD
if (updateDto.VigenciaH.HasValue && updateDto.VigenciaH.Value.Date < precioExistente.VigenciaD.Date)
var precioExistente = await _precioRepository.GetByIdAsync(idPrecio); // Obtener dentro de TX
if (precioExistente == null)
{
return (false, "La Vigencia Hasta no puede ser anterior a la Vigencia Desde.");
transaction.Rollback();
return (false, "Período de precio no encontrado.");
}
// Adicional: si se establece VigenciaH, verificar que no haya precios posteriores que se solapen
if (updateDto.VigenciaH.HasValue)
bool preciosDiasCambiaron =
(updateDto.Lunes.HasValue && updateDto.Lunes != precioExistente.Lunes) ||
(updateDto.Martes.HasValue && updateDto.Martes != precioExistente.Martes) ||
(updateDto.Miercoles.HasValue && updateDto.Miercoles != precioExistente.Miercoles) ||
(updateDto.Jueves.HasValue && updateDto.Jueves != precioExistente.Jueves) ||
(updateDto.Viernes.HasValue && updateDto.Viernes != precioExistente.Viernes) ||
(updateDto.Sabado.HasValue && updateDto.Sabado != precioExistente.Sabado) ||
(updateDto.Domingo.HasValue && updateDto.Domingo != precioExistente.Domingo);
if (precioExistente.VigenciaH != null && preciosDiasCambiaron)
{
var preciosPosteriores = await _precioRepository.GetByPublicacionIdAsync(precioExistente.IdPublicacion);
if (preciosPosteriores.Any(p => p.IdPrecio != idPrecio && p.VigenciaD.Date <= updateDto.VigenciaH.Value.Date && p.VigenciaD.Date > precioExistente.VigenciaD.Date ))
transaction.Rollback();
return (false, "No se pueden modificar los precios de los días de un período que ya ha sido cerrado.");
}
// Validación 2: No modificar precios de días si el período está en uso
if (preciosDiasCambiaron && await _precioRepository.IsInUseAsync(idPrecio, precioExistente.VigenciaD, precioExistente.VigenciaH))
{
transaction.Rollback();
return (false, "No se pueden modificar los precios de los días de este período porque ya existen movimientos asociados.");
}
// Solo realizar validaciones de VigenciaH si se está intentando SETEAR o CAMBIAR VigenciaH
if (updateDto.VigenciaH.HasValue) // <<--- CHEQUEO IMPORTANTE
{
// Validación 3: Nueva VigenciaH debe ser >= VigenciaD
if (updateDto.VigenciaH.Value.Date < precioExistente.VigenciaD.Date)
{
return (false, "No se puede cerrar este período porque existen períodos de precios posteriores que se solaparían. Elimine o ajuste los períodos posteriores primero.");
transaction.Rollback();
return (false, "La Vigencia Hasta no puede ser anterior a la Vigencia Desde.");
}
// Validación 4: Nueva VigenciaH no debe solaparse con períodos posteriores
var todosLosPreciosPub = await _precioRepository.GetByPublicacionIdAsync(precioExistente.IdPublicacion);
if (todosLosPreciosPub.Any(p =>
p.IdPrecio != idPrecio &&
p.VigenciaD.Date <= updateDto.VigenciaH.Value.Date &&
p.VigenciaD.Date > precioExistente.VigenciaD.Date &&
(p.VigenciaH == null || p.VigenciaH.Value.Date >= p.VigenciaD.Date)
))
{
transaction.Rollback();
return (false, "No se puede cerrar este período con la Vigencia Hasta especificada porque se solaparía con un período posterior existente. Ajuste los períodos posteriores primero.");
}
// Si pasa las validaciones, se asigna la nueva VigenciaH más abajo
}
// Si updateDto.VigenciaH es null, estas validaciones de fecha no aplican.
// Aplicar actualizaciones
bool seRealizoAlgunaActualizacion = false;
precioExistente.Lunes = updateDto.Lunes ?? precioExistente.Lunes;
precioExistente.Martes = updateDto.Martes ?? precioExistente.Martes;
precioExistente.Miercoles = updateDto.Miercoles ?? precioExistente.Miercoles;
precioExistente.Jueves = updateDto.Jueves ?? precioExistente.Jueves;
precioExistente.Viernes = updateDto.Viernes ?? precioExistente.Viernes;
precioExistente.Sabado = updateDto.Sabado ?? precioExistente.Sabado;
precioExistente.Domingo = updateDto.Domingo ?? precioExistente.Domingo;
if (updateDto.VigenciaH.HasValue) // Solo actualizar VigenciaH si se proporciona
// Aplicar actualizaciones
if (preciosDiasCambiaron)
{
precioExistente.VigenciaH = updateDto.VigenciaH.Value.Date;
precioExistente.Lunes = updateDto.Lunes ?? precioExistente.Lunes;
precioExistente.Martes = updateDto.Martes ?? precioExistente.Martes;
precioExistente.Miercoles = updateDto.Miercoles ?? precioExistente.Miercoles;
precioExistente.Jueves = updateDto.Jueves ?? precioExistente.Jueves;
precioExistente.Viernes = updateDto.Viernes ?? precioExistente.Viernes;
precioExistente.Sabado = updateDto.Sabado ?? precioExistente.Sabado;
precioExistente.Domingo = updateDto.Domingo ?? precioExistente.Domingo;
seRealizoAlgunaActualizacion = true;
}
// Actualizar VigenciaH solo si el valor recibido en el DTO es diferente al existente,
// o si se quiere pasar de un valor a null (reabrir) o de null a un valor (cerrar).
if ((updateDto.VigenciaH.HasValue && (!precioExistente.VigenciaH.HasValue || updateDto.VigenciaH.Value.Date != precioExistente.VigenciaH.Value.Date)) ||
(!updateDto.VigenciaH.HasValue && precioExistente.VigenciaH.HasValue))
{
precioExistente.VigenciaH = updateDto.VigenciaH.HasValue ? updateDto.VigenciaH.Value.Date : (DateTime?)null;
seRealizoAlgunaActualizacion = true;
}
var actualizado = await _precioRepository.UpdateAsync(precioExistente, idUsuario, transaction);
if (!actualizado) throw new DataException("Error al actualizar el período de precio.");
if (seRealizoAlgunaActualizacion)
{
var actualizado = await _precioRepository.UpdateAsync(precioExistente, idUsuario, transaction);
if (!actualizado) throw new DataException("Error al actualizar el período de precio.");
}
else
{
_logger.LogInformation("No se detectaron cambios para Precio ID {IdPrecio}. No se realizó actualización.", idPrecio);
}
transaction.Commit();
_logger.LogInformation("Precio ID {IdPrecio} actualizado por Usuario ID {IdUsuario}.", idPrecio, idUsuario);
_logger.LogInformation("Precio ID {IdPrecio} procesado (actualizado si hubo cambios) por Usuario ID {IdUsuario}.", idPrecio, idUsuario);
return (true, null);
}
catch (KeyNotFoundException) { try { transaction.Rollback(); } catch {} return (false, "Período de precio no encontrado.");}
catch (KeyNotFoundException) { try { transaction?.Rollback(); } catch { } return (false, "Período de precio no encontrado."); }
catch (Exception ex)
{
try { transaction.Rollback(); } catch {}
try { transaction?.Rollback(); } catch { }
_logger.LogError(ex, "Error ActualizarAsync Precio ID: {IdPrecio}", idPrecio);
return (false, $"Error interno al actualizar el período de precio: {ex.Message}");
}
finally
{
if (connection.State == ConnectionState.Open)
{
if (connection is System.Data.Common.DbConnection dbConnClose) await dbConnClose.CloseAsync(); else connection.Close();
}
}
}
public async Task<(bool Exito, string? Error)> EliminarAsync(int idPrecio, int idUsuario)
{
using var connection = _connectionFactory.CreateConnection();
using var connection = _connectionFactory.CreateConnection();
if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open();
using var transaction = connection.BeginTransaction();
try
{
var precioAEliminar = await _precioRepository.GetByIdAsync(idPrecio);
var precioAEliminar = await _precioRepository.GetByIdAsync(idPrecio); // Obtener dentro de TX
if (precioAEliminar == null) return (false, "Período de precio no encontrado.");
// Lógica de ajuste de VigenciaH del período anterior si este que se elimina era el "último" abierto.
// Si el precio a eliminar tiene un VigenciaH == null (estaba activo indefinidamente)
// Y existe un precio anterior para la misma publicación.
// Entonces, el VigenciaH de ese precio anterior debe volver a ser NULL.
// --- VERIFICACIÓN DE USO ---
if (await _precioRepository.IsInUseAsync(idPrecio, precioAEliminar.VigenciaD, precioAEliminar.VigenciaH))
{
transaction.Rollback(); // No olvidar rollback si la verificación falla
return (false, "No se puede eliminar. Este período de precio está referenciado en movimientos existentes.");
}
if (precioAEliminar.VigenciaH == null)
{
var todosLosPreciosPub = (await _precioRepository.GetByPublicacionIdAsync(precioAEliminar.IdPublicacion))
.OrderByDescending(p => p.VigenciaD).ToList();
var indiceActual = todosLosPreciosPub.FindIndex(p=> p.IdPrecio == idPrecio);
if(indiceActual != -1 && (indiceActual + 1) < todosLosPreciosPub.Count)
var indiceActual = todosLosPreciosPub.FindIndex(p => p.IdPrecio == idPrecio);
if (indiceActual != -1 && (indiceActual + 1) < todosLosPreciosPub.Count)
{
var precioAnteriorDirecto = todosLosPreciosPub[indiceActual + 1];
// Solo si el precioAnteriorDirecto fue cerrado por este que se elimina
if(precioAnteriorDirecto.VigenciaH.HasValue && precioAnteriorDirecto.VigenciaH.Value.Date == precioAEliminar.VigenciaD.AddDays(-1).Date)
if (precioAnteriorDirecto.VigenciaH.HasValue && precioAnteriorDirecto.VigenciaH.Value.Date == precioAEliminar.VigenciaD.AddDays(-1).Date)
{
precioAnteriorDirecto.VigenciaH = null;
await _precioRepository.UpdateAsync(precioAnteriorDirecto, idUsuario, transaction); // Usar un ID de auditoría adecuado
_logger.LogInformation("Precio anterior ID {IdPrecioAnterior} reabierto (VigenciaH a NULL) tras eliminación de Precio ID {IdPrecioEliminado}.", precioAnteriorDirecto.IdPrecio, idPrecio);
// Asegurar que UpdateAsync tome la transacción
await _precioRepository.UpdateAsync(precioAnteriorDirecto, idUsuario, transaction);
_logger.LogInformation("Precio anterior ID {IdPrecioAnterior} reabierto tras eliminación de Precio ID {IdPrecioEliminado}.", precioAnteriorDirecto.IdPrecio, idPrecio);
}
}
}
var eliminado = await _precioRepository.DeleteAsync(idPrecio, idUsuario, transaction);
if (!eliminado) throw new DataException("Error al eliminar el período de precio.");
@@ -218,13 +288,40 @@ namespace GestionIntegral.Api.Services.Distribucion
_logger.LogInformation("Precio ID {IdPrecio} eliminado por Usuario ID {IdUsuario}.", idPrecio, idUsuario);
return (true, null);
}
catch (KeyNotFoundException) { try { transaction.Rollback(); } catch {} return (false, "Período de precio no encontrado."); }
catch (KeyNotFoundException) { try { transaction.Rollback(); } catch { } return (false, "Período de precio no encontrado."); }
catch (Exception ex)
{
try { transaction.Rollback(); } catch {}
try { transaction.Rollback(); } catch { }
_logger.LogError(ex, "Error EliminarAsync Precio ID: {IdPrecio}", idPrecio);
return (false, $"Error interno al eliminar el período de precio: {ex.Message}");
}
}
public async Task<IEnumerable<PrecioHistorialDto>> ObtenerHistorialAsync(
DateTime? fechaDesde, DateTime? fechaHasta,
int? idUsuarioModifico, string? tipoModificacion,
int? idPrecioAfectado, int? idPublicacionAfectada)
{
var historialData = await _precioRepository.GetHistorialAsync(fechaDesde, fechaHasta, idUsuarioModifico, tipoModificacion, idPrecioAfectado, idPublicacionAfectada);
return historialData.Select(h => new PrecioHistorialDto
{
Id_Precio = h.Historial.Id_Precio,
Id_Publicacion = h.Historial.Id_Publicacion,
VigenciaD = h.Historial.VigenciaD,
VigenciaH = h.Historial.VigenciaH,
Lunes = h.Historial.Lunes,
Martes = h.Historial.Martes,
Miercoles = h.Historial.Miercoles,
Jueves = h.Historial.Jueves,
Viernes = h.Historial.Viernes,
Sabado = h.Historial.Sabado,
Domingo = h.Historial.Domingo,
Id_Usuario = h.Historial.Id_Usuario,
NombreUsuarioModifico = h.NombreUsuarioModifico,
FechaMod = h.Historial.FechaMod,
TipoMod = h.Historial.TipoMod
}).ToList();
}
}
}