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

138
Backend/GestionIntegral.Api/Controllers/Distribucion/EntradasSalidasDistController.cs Normal file
View File

@@ -0,0 +1,138 @@
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Services.Distribucion;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc.ModelBinding; // Para BindRequired
namespace GestionIntegral.Api.Controllers.Distribucion
{
[Route("api/entradassalidasdist")] // Ruta base
[ApiController]
[Authorize]
public class EntradasSalidasDistController : ControllerBase
{
private readonly IEntradaSalidaDistService _esService;
private readonly ILogger<EntradasSalidasDistController> _logger;
// Permisos para Entradas/Salidas Distribuidores (MD001, MD002)
// Asumo MD001 para Ver, MD002 para Crear/Modificar/Eliminar
private const string PermisoVerMovimientos = "MD001";
private const string PermisoGestionarMovimientos = "MD002";
public EntradasSalidasDistController(IEntradaSalidaDistService esService, ILogger<EntradasSalidasDistController> logger)
{
_esService = esService;
_logger = logger;
}
private bool TienePermiso(string codAcc) => User.IsInRole("SuperAdmin") || User.HasClaim(c => c.Type == "permission" && c.Value == codAcc);
private int? GetCurrentUserId()
{
if (int.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier) ?? User.FindFirstValue("sub"), out int userId)) return userId;
_logger.LogWarning("No se pudo obtener el UserId del token JWT en EntradasSalidasDistController.");
return null;
}
// GET: api/entradassalidasdist
[HttpGet]
[ProducesResponseType(typeof(IEnumerable<EntradaSalidaDistDto>), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> GetAll(
[FromQuery] DateTime? fechaDesde, [FromQuery] DateTime? fechaHasta,
[FromQuery] int? idPublicacion, [FromQuery] int? idDistribuidor,
[FromQuery] string? tipoMovimiento)
{
if (!TienePermiso(PermisoVerMovimientos)) return Forbid();
try
{
var movimientos = await _esService.ObtenerTodosAsync(fechaDesde, fechaHasta, idPublicacion, idDistribuidor, tipoMovimiento);
return Ok(movimientos);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error al obtener listado de Entradas/Salidas Dist.");
return StatusCode(StatusCodes.Status500InternalServerError, "Error interno.");
}
}
// GET: api/entradassalidasdist/{idParte}
[HttpGet("{idParte:int}", Name = "GetEntradaSalidaDistById")]
[ProducesResponseType(typeof(EntradaSalidaDistDto), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> GetById(int idParte)
{
if (!TienePermiso(PermisoVerMovimientos)) return Forbid();
var movimiento = await _esService.ObtenerPorIdAsync(idParte);
if (movimiento == null) return NotFound(new { message = $"Movimiento con ID {idParte} no encontrado." });
return Ok(movimiento);
}
// POST: api/entradassalidasdist
[HttpPost]
[ProducesResponseType(typeof(EntradaSalidaDistDto), StatusCodes.Status201Created)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> CreateMovimiento([FromBody] CreateEntradaSalidaDistDto createDto)
{
if (!TienePermiso(PermisoGestionarMovimientos)) return Forbid();
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var (dto, error) = await _esService.CrearMovimientoAsync(createDto, userId.Value);
if (error != null) return BadRequest(new { message = error });
if (dto == null) return StatusCode(StatusCodes.Status500InternalServerError, "Error al registrar el movimiento.");
return CreatedAtRoute("GetEntradaSalidaDistById", new { idParte = dto.IdParte }, dto);
}
// PUT: api/entradassalidasdist/{idParte}
[HttpPut("{idParte:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> UpdateMovimiento(int idParte, [FromBody] UpdateEntradaSalidaDistDto updateDto)
{
if (!TienePermiso(PermisoGestionarMovimientos)) return Forbid();
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var (exito, error) = await _esService.ActualizarMovimientoAsync(idParte, updateDto, userId.Value);
if (!exito)
{
if (error == "Movimiento no encontrado.") return NotFound(new { message = error });
return BadRequest(new { message = error });
}
return NoContent();
}
// DELETE: api/entradassalidasdist/{idParte}
[HttpDelete("{idParte:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> DeleteMovimiento(int idParte)
{
if (!TienePermiso(PermisoGestionarMovimientos)) return Forbid(); // Asumo que el mismo permiso sirve para eliminar
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var (exito, error) = await _esService.EliminarMovimientoAsync(idParte, userId.Value);
if (!exito)
{
if (error == "Movimiento no encontrado.") return NotFound(new { message = error });
return BadRequest(new { message = error });
}
return NoContent();
}
}
}

119
Backend/GestionIntegral.Api/Controllers/Distribucion/PorcentajesMonCanillaController.cs Normal file
View File

@@ -0,0 +1,119 @@
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Services.Distribucion;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Controllers.Distribucion
{
[Route("api/publicaciones/{idPublicacion}/porcentajesmoncanilla")] // Anidado
[ApiController]
[Authorize]
public class PorcentajesMonCanillaController : ControllerBase
{
private readonly IPorcMonCanillaService _porcMonCanillaService;
private readonly ILogger<PorcentajesMonCanillaController> _logger;
// Permiso CG004 para porcentajes de pago de canillitas
private const string PermisoGestionar = "CG004";
public PorcentajesMonCanillaController(IPorcMonCanillaService porcMonCanillaService, ILogger<PorcentajesMonCanillaController> logger)
{
_porcMonCanillaService = porcMonCanillaService;
_logger = logger;
}
private bool TienePermiso(string codAcc) => User.IsInRole("SuperAdmin") || User.HasClaim(c => c.Type == "permission" && c.Value == codAcc);
private int? GetCurrentUserId()
{
if (int.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier) ?? User.FindFirstValue("sub"), out int userId)) return userId;
return null;
}
[HttpGet]
[ProducesResponseType(typeof(IEnumerable<PorcMonCanillaDto>), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> GetPorcMonCanillaPorPublicacion(int idPublicacion)
{
// DP001 para ver publicación, CG004 para gestionar específicamente esto
if (!TienePermiso("DP001") && !TienePermiso(PermisoGestionar)) return Forbid();
var items = await _porcMonCanillaService.ObtenerPorPublicacionIdAsync(idPublicacion);
return Ok(items);
}
[HttpGet("{idPorcMon:int}", Name = "GetPorcMonCanillaById")]
[ProducesResponseType(typeof(PorcMonCanillaDto), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> GetPorcMonCanillaById(int idPublicacion, int idPorcMon)
{
if (!TienePermiso("DP001") && !TienePermiso(PermisoGestionar)) return Forbid();
var item = await _porcMonCanillaService.ObtenerPorIdAsync(idPorcMon);
if (item == null || item.IdPublicacion != idPublicacion) return NotFound();
return Ok(item);
}
[HttpPost]
[ProducesResponseType(typeof(PorcMonCanillaDto), StatusCodes.Status201Created)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> CreatePorcMonCanilla(int idPublicacion, [FromBody] CreatePorcMonCanillaDto createDto)
{
if (!TienePermiso(PermisoGestionar)) return Forbid();
if (idPublicacion != createDto.IdPublicacion)
return BadRequest(new { message = "ID de publicación en ruta no coincide con el del cuerpo." });
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var (dto, error) = await _porcMonCanillaService.CrearAsync(createDto, userId.Value);
if (error != null) return BadRequest(new { message = error });
if (dto == null) return StatusCode(StatusCodes.Status500InternalServerError, "Error al crear.");
return CreatedAtRoute("GetPorcMonCanillaById", new { idPublicacion = dto.IdPublicacion, idPorcMon = dto.IdPorcMon }, dto);
}
[HttpPut("{idPorcMon:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> UpdatePorcMonCanilla(int idPublicacion, int idPorcMon, [FromBody] UpdatePorcMonCanillaDto updateDto)
{
if (!TienePermiso(PermisoGestionar)) return Forbid();
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var existente = await _porcMonCanillaService.ObtenerPorIdAsync(idPorcMon);
if (existente == null || existente.IdPublicacion != idPublicacion)
return NotFound(new { message = "Registro no encontrado para esta publicación."});
var (exito, error) = await _porcMonCanillaService.ActualizarAsync(idPorcMon, updateDto, userId.Value);
if (!exito) return BadRequest(new { message = error });
return NoContent();
}
[HttpDelete("{idPorcMon:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> DeletePorcMonCanilla(int idPublicacion, int idPorcMon)
{
if (!TienePermiso(PermisoGestionar)) return Forbid();
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var existente = await _porcMonCanillaService.ObtenerPorIdAsync(idPorcMon);
if (existente == null || existente.IdPublicacion != idPublicacion)
return NotFound(new { message = "Registro no encontrado para esta publicación."});
var (exito, error) = await _porcMonCanillaService.EliminarAsync(idPorcMon, userId.Value);
if (!exito) return BadRequest(new { message = error });
return NoContent();
}
}
}

118
Backend/GestionIntegral.Api/Controllers/Distribucion/PorcentajesPagoController.cs Normal file
View File

@@ -0,0 +1,118 @@
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Services.Distribucion;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Controllers.Distribucion
{
[Route("api/publicaciones/{idPublicacion}/porcentajespago")] // Anidado
[ApiController]
[Authorize]
public class PorcentajesPagoController : ControllerBase // Para Porcentajes de Pago Distribuidores
{
private readonly IPorcPagoService _porcPagoService;
private readonly ILogger<PorcentajesPagoController> _logger;
// Permiso DG004 para gestionar porcentajes de pago de distribuidores
private const string PermisoGestionarPorcentajes = "DG004";
public PorcentajesPagoController(IPorcPagoService porcPagoService, ILogger<PorcentajesPagoController> logger)
{
_porcPagoService = porcPagoService;
_logger = logger;
}
private bool TienePermiso(string codAcc) => User.IsInRole("SuperAdmin") || User.HasClaim(c => c.Type == "permission" && c.Value == codAcc);
private int? GetCurrentUserId()
{
if (int.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier) ?? User.FindFirstValue("sub"), out int userId)) return userId;
return null;
}
[HttpGet]
[ProducesResponseType(typeof(IEnumerable<PorcPagoDto>), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> GetPorcentajesPorPublicacion(int idPublicacion)
{
if (!TienePermiso("DP001") && !TienePermiso(PermisoGestionarPorcentajes)) return Forbid(); // DP001 para ver Publicación
var porcentajes = await _porcPagoService.ObtenerPorPublicacionIdAsync(idPublicacion);
return Ok(porcentajes);
}
[HttpGet("{idPorcentaje:int}", Name = "GetPorcPagoById")]
[ProducesResponseType(typeof(PorcPagoDto), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> GetPorcPagoById(int idPublicacion, int idPorcentaje)
{
if (!TienePermiso("DP001") && !TienePermiso(PermisoGestionarPorcentajes)) return Forbid();
var porcPago = await _porcPagoService.ObtenerPorIdAsync(idPorcentaje);
if (porcPago == null || porcPago.IdPublicacion != idPublicacion) return NotFound();
return Ok(porcPago);
}
[HttpPost]
[ProducesResponseType(typeof(PorcPagoDto), StatusCodes.Status201Created)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> CreatePorcPago(int idPublicacion, [FromBody] CreatePorcPagoDto createDto)
{
if (!TienePermiso(PermisoGestionarPorcentajes)) return Forbid();
if (idPublicacion != createDto.IdPublicacion)
return BadRequest(new { message = "ID de publicación en ruta no coincide con el del cuerpo." });
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var (dto, error) = await _porcPagoService.CrearAsync(createDto, userId.Value);
if (error != null) return BadRequest(new { message = error });
if (dto == null) return StatusCode(StatusCodes.Status500InternalServerError, "Error al crear porcentaje.");
return CreatedAtRoute("GetPorcPagoById", new { idPublicacion = dto.IdPublicacion, idPorcentaje = dto.IdPorcentaje }, dto);
}
[HttpPut("{idPorcentaje:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> UpdatePorcPago(int idPublicacion, int idPorcentaje, [FromBody] UpdatePorcPagoDto updateDto)
{
if (!TienePermiso(PermisoGestionarPorcentajes)) return Forbid();
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var existente = await _porcPagoService.ObtenerPorIdAsync(idPorcentaje);
if (existente == null || existente.IdPublicacion != idPublicacion)
return NotFound(new { message = "Porcentaje no encontrado para esta publicación."});
var (exito, error) = await _porcPagoService.ActualizarAsync(idPorcentaje, updateDto, userId.Value);
if (!exito) return BadRequest(new { message = error });
return NoContent();
}
[HttpDelete("{idPorcentaje:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> DeletePorcPago(int idPublicacion, int idPorcentaje)
{
if (!TienePermiso(PermisoGestionarPorcentajes)) return Forbid();
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var existente = await _porcPagoService.ObtenerPorIdAsync(idPorcentaje);
if (existente == null || existente.IdPublicacion != idPublicacion)
return NotFound(new { message = "Porcentaje no encontrado para esta publicación."});
var (exito, error) = await _porcPagoService.EliminarAsync(idPorcentaje, userId.Value);
if (!exito) return BadRequest(new { message = error });
return NoContent();
}
}
}

124
Backend/GestionIntegral.Api/Controllers/Distribucion/PubliSeccionesController.cs Normal file
View File

@@ -0,0 +1,124 @@
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Services.Distribucion;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Controllers.Distribucion
{
[Route("api/publicaciones/{idPublicacion}/secciones")] // Anidado
[ApiController]
[Authorize]
public class PubliSeccionesController : ControllerBase
{
private readonly IPubliSeccionService _publiSeccionService;
private readonly ILogger<PubliSeccionesController> _logger;
// Permiso DP007 para gestionar secciones de publicaciones
private const string PermisoGestionarSecciones = "DP007";
public PubliSeccionesController(IPubliSeccionService publiSeccionService, ILogger<PubliSeccionesController> logger)
{
_publiSeccionService = publiSeccionService;
_logger = logger;
}
private bool TienePermiso(string codAcc) => User.IsInRole("SuperAdmin") || User.HasClaim(c => c.Type == "permission" && c.Value == codAcc);
private int? GetCurrentUserId()
{
if (int.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier) ?? User.FindFirstValue("sub"), out int userId)) return userId;
return null;
}
// GET: api/publicaciones/{idPublicacion}/secciones
[HttpGet]
[ProducesResponseType(typeof(IEnumerable<PubliSeccionDto>), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> GetSeccionesPorPublicacion(int idPublicacion, [FromQuery] bool? soloActivas)
{
// DP001 para ver publicación, DP007 para gestionar específicamente secciones
if (!TienePermiso("DP001") && !TienePermiso(PermisoGestionarSecciones)) return Forbid();
var secciones = await _publiSeccionService.ObtenerPorPublicacionIdAsync(idPublicacion, soloActivas);
return Ok(secciones);
}
// GET: api/publicaciones/{idPublicacion}/secciones/{idSeccion}
[HttpGet("{idSeccion:int}", Name = "GetPubliSeccionById")]
[ProducesResponseType(typeof(PubliSeccionDto), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> GetPubliSeccionById(int idPublicacion, int idSeccion)
{
if (!TienePermiso("DP001") && !TienePermiso(PermisoGestionarSecciones)) return Forbid();
var seccion = await _publiSeccionService.ObtenerPorIdAsync(idSeccion);
if (seccion == null || seccion.IdPublicacion != idPublicacion) return NotFound();
return Ok(seccion);
}
// POST: api/publicaciones/{idPublicacion}/secciones
[HttpPost]
[ProducesResponseType(typeof(PubliSeccionDto), StatusCodes.Status201Created)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> CreatePubliSeccion(int idPublicacion, [FromBody] CreatePubliSeccionDto createDto)
{
if (!TienePermiso(PermisoGestionarSecciones)) return Forbid();
if (idPublicacion != createDto.IdPublicacion)
return BadRequest(new { message = "ID de publicación en ruta no coincide con el del cuerpo." });
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var (dto, error) = await _publiSeccionService.CrearAsync(createDto, userId.Value);
if (error != null) return BadRequest(new { message = error });
if (dto == null) return StatusCode(StatusCodes.Status500InternalServerError, "Error al crear sección.");
return CreatedAtRoute("GetPubliSeccionById", new { idPublicacion = dto.IdPublicacion, idSeccion = dto.IdSeccion }, dto);
}
// PUT: api/publicaciones/{idPublicacion}/secciones/{idSeccion}
[HttpPut("{idSeccion:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> UpdatePubliSeccion(int idPublicacion, int idSeccion, [FromBody] UpdatePubliSeccionDto updateDto)
{
if (!TienePermiso(PermisoGestionarSecciones)) return Forbid();
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var existente = await _publiSeccionService.ObtenerPorIdAsync(idSeccion);
if (existente == null || existente.IdPublicacion != idPublicacion)
return NotFound(new { message = "Sección no encontrada para esta publicación."});
var (exito, error) = await _publiSeccionService.ActualizarAsync(idSeccion, updateDto, userId.Value);
if (!exito) return BadRequest(new { message = error });
return NoContent();
}
// DELETE: api/publicaciones/{idPublicacion}/secciones/{idSeccion}
[HttpDelete("{idSeccion:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> DeletePubliSeccion(int idPublicacion, int idSeccion)
{
if (!TienePermiso(PermisoGestionarSecciones)) return Forbid();
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var existente = await _publiSeccionService.ObtenerPorIdAsync(idSeccion);
if (existente == null || existente.IdPublicacion != idPublicacion)
return NotFound(new { message = "Sección no encontrada para esta publicación."});
var (exito, error) = await _publiSeccionService.EliminarAsync(idSeccion, userId.Value);
if (!exito) return BadRequest(new { message = error });
return NoContent();
}
}
}

123
Backend/GestionIntegral.Api/Controllers/Distribucion/RecargosZonaController.cs Normal file
View File

@@ -0,0 +1,123 @@
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Services.Distribucion;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Controllers.Distribucion
{
[Route("api/publicaciones/{idPublicacion}/recargos")] // Anidado bajo publicaciones
[ApiController]
[Authorize]
public class RecargosZonaController : ControllerBase
{
private readonly IRecargoZonaService _recargoZonaService;
private readonly ILogger<RecargosZonaController> _logger;
// Permiso DP005 para gestionar recargos
private const string PermisoGestionarRecargos = "DP005";
public RecargosZonaController(IRecargoZonaService recargoZonaService, ILogger<RecargosZonaController> logger)
{
_recargoZonaService = recargoZonaService;
_logger = logger;
}
private bool TienePermiso(string codAcc) => User.IsInRole("SuperAdmin") || User.HasClaim(c => c.Type == "permission" && c.Value == codAcc);
private int? GetCurrentUserId()
{
if (int.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier) ?? User.FindFirstValue("sub"), out int userId)) return userId;
return null;
}
// GET: api/publicaciones/{idPublicacion}/recargos
[HttpGet]
[ProducesResponseType(typeof(IEnumerable<RecargoZonaDto>), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> GetRecargosPorPublicacion(int idPublicacion)
{
if (!TienePermiso("DP001") && !TienePermiso(PermisoGestionarRecargos)) return Forbid();
var recargos = await _recargoZonaService.ObtenerPorPublicacionIdAsync(idPublicacion);
return Ok(recargos);
}
// GET: api/publicaciones/{idPublicacion}/recargos/{idRecargo}
[HttpGet("{idRecargo:int}", Name = "GetRecargoZonaById")]
[ProducesResponseType(typeof(RecargoZonaDto), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> GetRecargoZonaById(int idPublicacion, int idRecargo)
{
if (!TienePermiso("DP001") && !TienePermiso(PermisoGestionarRecargos)) return Forbid();
var recargo = await _recargoZonaService.ObtenerPorIdAsync(idRecargo);
if (recargo == null || recargo.IdPublicacion != idPublicacion) return NotFound();
return Ok(recargo);
}
// POST: api/publicaciones/{idPublicacion}/recargos
[HttpPost]
[ProducesResponseType(typeof(RecargoZonaDto), StatusCodes.Status201Created)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> CreateRecargoZona(int idPublicacion, [FromBody] CreateRecargoZonaDto createDto)
{
if (!TienePermiso(PermisoGestionarRecargos)) return Forbid();
if (idPublicacion != createDto.IdPublicacion)
return BadRequest(new { message = "ID de publicación en ruta no coincide con el del cuerpo." });
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var (dto, error) = await _recargoZonaService.CrearAsync(createDto, userId.Value);
if (error != null) return BadRequest(new { message = error });
if (dto == null) return StatusCode(StatusCodes.Status500InternalServerError, "Error al crear recargo.");
return CreatedAtRoute("GetRecargoZonaById", new { idPublicacion = dto.IdPublicacion, idRecargo = dto.IdRecargo }, dto);
}
// PUT: api/publicaciones/{idPublicacion}/recargos/{idRecargo}
[HttpPut("{idRecargo:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> UpdateRecargoZona(int idPublicacion, int idRecargo, [FromBody] UpdateRecargoZonaDto updateDto)
{
if (!TienePermiso(PermisoGestionarRecargos)) return Forbid();
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var recargoExistente = await _recargoZonaService.ObtenerPorIdAsync(idRecargo);
if (recargoExistente == null || recargoExistente.IdPublicacion != idPublicacion)
return NotFound(new { message = "Recargo no encontrado para esta publicación."});
var (exito, error) = await _recargoZonaService.ActualizarAsync(idRecargo, updateDto, userId.Value);
if (!exito) return BadRequest(new { message = error });
return NoContent();
}
// DELETE: api/publicaciones/{idPublicacion}/recargos/{idRecargo}
[HttpDelete("{idRecargo:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> DeleteRecargoZona(int idPublicacion, int idRecargo)
{
if (!TienePermiso(PermisoGestionarRecargos)) return Forbid();
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var recargoExistente = await _recargoZonaService.ObtenerPorIdAsync(idRecargo);
if (recargoExistente == null || recargoExistente.IdPublicacion != idPublicacion)
return NotFound(new { message = "Recargo no encontrado para esta publicación."});
var (exito, error) = await _recargoZonaService.EliminarAsync(idRecargo, userId.Value);
if (!exito) return BadRequest(new { message = error });
return NoContent();
}
}
}

128
Backend/GestionIntegral.Api/Controllers/Distribucion/SalidasOtrosDestinosController.cs Normal file
View File

@@ -0,0 +1,128 @@
using GestionIntegral.Api.Dtos.Distribucion;
using GestionIntegral.Api.Services.Distribucion;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Controllers.Distribucion
{
[Route("api/[controller]")] // Ruta base: /api/salidasotrosdestinos
[ApiController]
[Authorize]
public class SalidasOtrosDestinosController : ControllerBase
{
private readonly ISalidaOtroDestinoService _salidaService;
private readonly ILogger<SalidasOtrosDestinosController> _logger;
// Permisos para Salidas Otros Destinos (SO001 a SO003, asumiendo OD00X para la entidad OtrosDestinos)
private const string PermisoVerSalidasOD = "SO001";
private const string PermisoCrearSalidaOD = "SO002"; // Asumo SO002 para crear/modificar basado en tu excel
private const string PermisoModificarSalidaOD = "SO002"; // "
private const string PermisoEliminarSalidaOD = "SO003";
public SalidasOtrosDestinosController(ISalidaOtroDestinoService salidaService, ILogger<SalidasOtrosDestinosController> logger)
{
_salidaService = salidaService;
_logger = logger;
}
private bool TienePermiso(string codAcc) => User.IsInRole("SuperAdmin") || User.HasClaim(c => c.Type == "permission" && c.Value == codAcc);
private int? GetCurrentUserId()
{
if (int.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier) ?? User.FindFirstValue("sub"), out int userId)) return userId;
_logger.LogWarning("No se pudo obtener el UserId del token JWT en SalidasOtrosDestinosController.");
return null;
}
// GET: api/salidasotrosdestinos
[HttpGet]
[ProducesResponseType(typeof(IEnumerable<SalidaOtroDestinoDto>), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> GetAllSalidas(
[FromQuery] DateTime? fechaDesde, [FromQuery] DateTime? fechaHasta,
[FromQuery] int? idPublicacion, [FromQuery] int? idDestino)
{
if (!TienePermiso(PermisoVerSalidasOD)) return Forbid();
var salidas = await _salidaService.ObtenerTodosAsync(fechaDesde, fechaHasta, idPublicacion, idDestino);
return Ok(salidas);
}
// GET: api/salidasotrosdestinos/{idParte}
[HttpGet("{idParte:int}", Name = "GetSalidaOtroDestinoById")]
[ProducesResponseType(typeof(SalidaOtroDestinoDto), StatusCodes.Status200OK)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> GetSalidaOtroDestinoById(int idParte)
{
if (!TienePermiso(PermisoVerSalidasOD)) return Forbid();
var salida = await _salidaService.ObtenerPorIdAsync(idParte);
if (salida == null) return NotFound();
return Ok(salida);
}
// POST: api/salidasotrosdestinos
[HttpPost]
[ProducesResponseType(typeof(SalidaOtroDestinoDto), StatusCodes.Status201Created)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
public async Task<IActionResult> CreateSalidaOtroDestino([FromBody] CreateSalidaOtroDestinoDto createDto)
{
if (!TienePermiso(PermisoCrearSalidaOD)) return Forbid();
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var (dto, error) = await _salidaService.CrearAsync(createDto, userId.Value);
if (error != null) return BadRequest(new { message = error });
if (dto == null) return StatusCode(StatusCodes.Status500InternalServerError, "Error al registrar la salida.");
return CreatedAtRoute("GetSalidaOtroDestinoById", new { idParte = dto.IdParte }, dto);
}
// PUT: api/salidasotrosdestinos/{idParte}
[HttpPut("{idParte:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> UpdateSalidaOtroDestino(int idParte, [FromBody] UpdateSalidaOtroDestinoDto updateDto)
{
if (!TienePermiso(PermisoModificarSalidaOD)) return Forbid(); // O SO002 si se usa para modificar
if (!ModelState.IsValid) return BadRequest(ModelState);
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var (exito, error) = await _salidaService.ActualizarAsync(idParte, updateDto, userId.Value);
if (!exito)
{
if (error == "Registro de salida no encontrado.") return NotFound(new { message = error });
return BadRequest(new { message = error });
}
return NoContent();
}
// DELETE: api/salidasotrosdestinos/{idParte}
[HttpDelete("{idParte:int}")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status403Forbidden)]
[ProducesResponseType(StatusCodes.Status404NotFound)]
public async Task<IActionResult> DeleteSalidaOtroDestino(int idParte)
{
if (!TienePermiso(PermisoEliminarSalidaOD)) return Forbid();
var userId = GetCurrentUserId();
if (userId == null) return Unauthorized();
var (exito, error) = await _salidaService.EliminarAsync(idParte, userId.Value);
if (!exito)
{
if (error == "Registro de salida no encontrado.") return NotFound(new { message = error });
return BadRequest(new { message = error });
}
return NoContent();
}
}
}