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

feat: Implementación CRUD Canillitas, Distribuidores y Precios de Publicación

Browse Source 
Backend API:
- Canillitas (`dist_dtCanillas`):
  - Implementado CRUD completo (Modelos, DTOs, Repositorio, Servicio, Controlador).
  - Lógica para manejo de `Accionista`, `Baja`, `FechaBaja`.
  - Auditoría en `dist_dtCanillas_H`.
  - Validación de legajo único y lógica de empresa vs accionista.
- Distribuidores (`dist_dtDistribuidores`):
  - Implementado CRUD completo (Modelos, DTOs, Repositorio, Servicio, Controlador).
  - Auditoría en `dist_dtDistribuidores_H`.
  - Creación de saldos iniciales para el nuevo distribuidor en todas las empresas.
  - Verificación de NroDoc único y Nombre opcionalmente único.
- Precios de Publicación (`dist_Precios`):
  - Implementado CRUD básico (Modelos, DTOs, Repositorio, Servicio, Controlador).
  - Endpoints anidados bajo `/publicaciones/{idPublicacion}/precios`.
  - Lógica de negocio para cerrar período de precio anterior al crear uno nuevo.
  - Lógica de negocio para reabrir período de precio anterior al eliminar el último.
  - Auditoría en `dist_Precios_H`.
- Auditoría en Eliminación de Publicaciones:
  - Extendido `PublicacionService.EliminarAsync` para eliminar en cascada registros de precios, recargos, porcentajes de pago (distribuidores y canillitas) y secciones de publicación.
  - Repositorios correspondientes (`PrecioRepository`, `RecargoZonaRepository`, `PorcPagoRepository`, `PorcMonCanillaRepository`, `PubliSeccionRepository`) actualizados con métodos `DeleteByPublicacionIdAsync` que registran en sus respectivas tablas `_H` (si existen y se implementó la lógica).
  - Asegurada la correcta propagación del `idUsuario` para la auditoría en cascada.
- Correcciones de Nulabilidad:
  - Ajustados los métodos `MapToDto` y su uso en `CanillaService` y `PublicacionService` para manejar correctamente tipos anulables.

Frontend React:
- Canillitas:
  - `canillaService.ts`.
  - `CanillaFormModal.tsx` con selectores para Zona y Empresa, y lógica de Accionista.
  - `GestionarCanillitasPage.tsx` con filtros, paginación, y acciones (editar, toggle baja).
- Distribuidores:
  - `distribuidorService.ts`.
  - `DistribuidorFormModal.tsx` con múltiples campos y selector de Zona.
  - `GestionarDistribuidoresPage.tsx` con filtros, paginación, y acciones (editar, eliminar).
- Precios de Publicación:
  - `precioService.ts`.
  - `PrecioFormModal.tsx` para crear/editar períodos de precios (VigenciaD, VigenciaH opcional, precios por día).
  - `GestionarPreciosPublicacionPage.tsx` accesible desde la gestión de publicaciones, para listar y gestionar los períodos de precios de una publicación específica.
- Layout:
  - Reemplazado el uso de `Grid` por `Box` con Flexbox en `CanillaFormModal`, `GestionarCanillitasPage` (filtros), `DistribuidorFormModal` y `PrecioFormModal` para resolver problemas de tipos y mejorar la consistencia del layout de formularios.
- Navegación:
  - Actualizadas las rutas y pestañas para los nuevos módulos y sub-módulos.
This commit is contained in:
eldiadmolinari
2025-05-20 12:38:55 -03:00
parent daf84d2708
commit b6ba52f074
228 changed files with 10745 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

230
Backend/GestionIntegral.Api/Services/Distribucion/PrecioService.cs Normal file
View File

@@ -0,0 +1,230 @@
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.Globalization;
using System.Linq;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Services.Distribucion
{
public class PrecioService : IPrecioService
{
private readonly IPrecioRepository _precioRepository;
private readonly IPublicacionRepository _publicacionRepository; // Para validar IdPublicacion
private readonly DbConnectionFactory _connectionFactory;
private readonly ILogger<PrecioService> _logger;
public PrecioService(
IPrecioRepository precioRepository,
IPublicacionRepository publicacionRepository,
DbConnectionFactory connectionFactory,
ILogger<PrecioService> logger)
{
_precioRepository = precioRepository;
_publicacionRepository = publicacionRepository;
_connectionFactory = connectionFactory;
_logger = logger;
}
private PrecioDto MapToDto(Precio precio) => new PrecioDto
{
IdPrecio = precio.IdPrecio,
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
};
public async Task<IEnumerable<PrecioDto>> ObtenerPorPublicacionIdAsync(int idPublicacion)
{
var precios = await _precioRepository.GetByPublicacionIdAsync(idPublicacion);
return precios.Select(MapToDto);
}
public async Task<PrecioDto?> ObtenerPorIdAsync(int idPrecio)
{
var precio = await _precioRepository.GetByIdAsync(idPrecio);
return precio == null ? null : MapToDto(precio);
}
public async Task<(PrecioDto? Precio, string? Error)> CrearAsync(CreatePrecioDto createDto, int idUsuario)
{
if (await _publicacionRepository.GetByIdSimpleAsync(createDto.IdPublicacion) == null)
return (null, "La publicación especificada no existe.");
// Validar que no haya solapamiento de fechas o que VigenciaD sea lógica
// Un precio no puede empezar antes que el VigenciaH de un precio anterior no cerrado.
// Y no puede empezar en una fecha donde ya existe un precio activo para esa publicación.
var precioActivoEnFecha = await _precioRepository.GetActiveByPublicacionAndDateAsync(createDto.IdPublicacion, createDto.VigenciaD);
if (precioActivoEnFecha != null)
{
return (null, $"Ya existe un período de precios activo para esta publicación en la fecha {createDto.VigenciaD:dd/MM/yyyy}. Primero debe cerrar el período anterior.");
}
var nuevoPrecio = new Precio
{
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
};
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
{
// 1. Buscar el precio anterior activo para esta publicación que no tenga VigenciaH
var precioAnterior = await _precioRepository.GetPreviousActivePriceAsync(createDto.IdPublicacion, nuevoPrecio.VigenciaD, transaction);
if (precioAnterior != null)
{
if (precioAnterior.VigenciaD >= nuevoPrecio.VigenciaD)
{
transaction.Rollback();
return (null, $"La fecha de inicio del nuevo precio ({nuevoPrecio.VigenciaD:dd/MM/yyyy}) no puede ser anterior o igual a la del último precio vigente ({precioAnterior.VigenciaD:dd/MM/yyyy}).");
}
// 2. Si existe, actualizar su VigenciaH al día anterior de la VigenciaD del nuevo precio
precioAnterior.VigenciaH = nuevoPrecio.VigenciaD.AddDays(-1);
bool actualizado = await _precioRepository.UpdateAsync(precioAnterior, idUsuario, transaction); // Usar un idUsuario de sistema/auditoría para esta acción automática si es necesario
if (!actualizado)
{
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);
}
// 3. Crear el nuevo registro de precio
var precioCreado = await _precioRepository.CreateAsync(nuevoPrecio, idUsuario, transaction);
if (precioCreado == null) throw new DataException("Error al crear el nuevo precio.");
transaction.Commit();
_logger.LogInformation("Precio ID {IdPrecio} creado para Publicación ID {IdPublicacion} por Usuario ID {IdUsuario}.", precioCreado.IdPrecio, precioCreado.IdPublicacion, idUsuario);
return (MapToDto(precioCreado), null);
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch { }
_logger.LogError(ex, "Error CrearAsync Precio para Publicación ID {IdPublicacion}", createDto.IdPublicacion);
return (null, $"Error interno al crear el precio: {ex.Message}");
}
}
public async Task<(bool Exito, string? Error)> ActualizarAsync(int idPrecio, UpdatePrecioDto updateDto, int idUsuario)
{
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 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)
{
return (false, "La Vigencia Hasta no puede ser anterior a la Vigencia Desde.");
}
// Adicional: si se establece VigenciaH, verificar que no haya precios posteriores que se solapen
if (updateDto.VigenciaH.HasValue)
{
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 ))
{
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.");
}
}
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
{
precioExistente.VigenciaH = updateDto.VigenciaH.Value.Date;
}
var actualizado = await _precioRepository.UpdateAsync(precioExistente, idUsuario, transaction);
if (!actualizado) throw new DataException("Error al actualizar el período de precio.");
transaction.Commit();
_logger.LogInformation("Precio ID {IdPrecio} actualizado por Usuario ID {IdUsuario}.", idPrecio, idUsuario);
return (true, null);
}
catch (KeyNotFoundException) { try { transaction.Rollback(); } catch {} return (false, "Período de precio no encontrado.");}
catch (Exception ex)
{
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}");
}
}
public async Task<(bool Exito, string? Error)> EliminarAsync(int idPrecio, int idUsuario)
{
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);
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.
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 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)
{
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);
}
}
}
var eliminado = await _precioRepository.DeleteAsync(idPrecio, idUsuario, transaction);
if (!eliminado) throw new DataException("Error al eliminar el período de precio.");
transaction.Commit();
_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 (Exception ex)
{
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}");
}
}
}
}