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

feat: Implementación módulos Empresas, Plantas, Tipos y Estados Bobina

Browse Source 
Backend API:
- Implementado CRUD completo para Empresas (DE001-DE004):
  - EmpresaRepository, EmpresaService, EmpresasController.
  - Lógica de creación/eliminación de saldos iniciales en EmpresaService.
  - Transacciones y registro en tablas _H.
  - Verificación de permisos específicos.
- Implementado CRUD completo para Plantas de Impresión (IP001-IP004):
  - PlantaRepository, PlantaService, PlantasController.
  - Transacciones y registro en tablas _H.
  - Verificación de permisos.
- Implementado CRUD completo para Tipos de Bobina (IB006-IB009):
  - TipoBobinaRepository, TipoBobinaService, TiposBobinaController.
  - Transacciones y registro en tablas _H.
  - Verificación de permisos.
- Implementado CRUD completo para Estados de Bobina (IB010-IB013):
  - EstadoBobinaRepository, EstadoBobinaService, EstadosBobinaController.
  - Transacciones y registro en tablas _H.
  - Verificación de permisos.

Frontend React:
- Módulo Empresas:
  - empresaService.ts para interactuar con la API.
  - EmpresaFormModal.tsx para crear/editar empresas.
  - GestionarEmpresasPage.tsx con tabla, filtro, paginación y menú de acciones.
  - Integración con el hook usePermissions para control de acceso.
- Módulo Plantas de Impresión:
  - plantaService.ts.
  - PlantaFormModal.tsx.
  - GestionarPlantasPage.tsx con tabla, filtro, paginación y acciones.
  - Integración con usePermissions.
- Módulo Tipos de Bobina:
  - tipoBobinaService.ts.
  - TipoBobinaFormModal.tsx.
  - GestionarTiposBobinaPage.tsx con tabla, filtro, paginación y acciones.
  - Integración con usePermissions.
- Módulo Estados de Bobina:
  - estadoBobinaService.ts.
  - EstadoBobinaFormModal.tsx.
  - GestionarEstadosBobinaPage.tsx con tabla, filtro, paginación y acciones.
  - Integración con usePermissions.
- Navegación:
  - Añadidas sub-pestañas y rutas para los nuevos módulos dentro de "Distribución" (Empresas) e "Impresión" (Plantas, Tipos Bobina, Estados Bobina).
  - Creado ImpresionIndexPage.tsx para la navegación interna del módulo de Impresión.

Correcciones:
- Corregido el uso de CommitAsync/RollbackAsync a Commit/Rollback síncronos en PlantaService.cs debido a que IDbTransaction no los soporta asíncronamente.
This commit is contained in:
Diego Molinari
2025-05-09 10:08:53 -03:00
parent 5c4b961073
commit daf84d2708
98 changed files with 6059 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Backend/GestionIntegral.Api/Services/Contables/TipoPagoService.cs
View File

@@ -1,4 +1,4 @@
using GestionIntegral.Api.Data.Repositories; // Para ITipoPagoRepository
using GestionIntegral.Api.Data.Repositories.Contables;
using GestionIntegral.Api.Dtos.Contables;
using GestionIntegral.Api.Models.Contables; // Para TipoPago
using GestionIntegral.Api.Services.Contables;

238
Backend/GestionIntegral.Api/Services/Distribucion/EmpresaService.cs Normal file
View File

@@ -0,0 +1,238 @@
using GestionIntegral.Api.Dtos.Empresas; // Para los DTOs (EmpresaDto, CreateEmpresaDto, UpdateEmpresaDto)
using Microsoft.Extensions.Logging; // Para ILogger
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
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
namespace GestionIntegral.Api.Services.Distribucion
{
public class EmpresaService : IEmpresaService
{
private readonly IEmpresaRepository _empresaRepository;
private readonly ISaldoRepository _saldoRepository;
private readonly DbConnectionFactory _connectionFactory; // Para manejar la transacción
private readonly ILogger<EmpresaService> _logger;
public EmpresaService(
IEmpresaRepository empresaRepository,
ISaldoRepository saldoRepository,
DbConnectionFactory connectionFactory,
ILogger<EmpresaService> logger)
{
_empresaRepository = empresaRepository;
_saldoRepository = saldoRepository;
_connectionFactory = connectionFactory;
_logger = logger;
}
public async Task<IEnumerable<EmpresaDto>> ObtenerTodasAsync(string? nombreFilter, string? detalleFilter)
{
// El repositorio ya devuelve solo las activas si es necesario
var empresas = await _empresaRepository.GetAllAsync(nombreFilter, detalleFilter);
// Mapeo Entidad -> DTO
return empresas.Select(e => new EmpresaDto
{
IdEmpresa = e.IdEmpresa,
Nombre = e.Nombre,
Detalle = e.Detalle
});
}
public async Task<EmpresaDto?> ObtenerPorIdAsync(int id)
{
// El repositorio ya devuelve solo las activas si es necesario
var empresa = await _empresaRepository.GetByIdAsync(id);
if (empresa == null) return null;
// Mapeo Entidad -> DTO
return new EmpresaDto
{
IdEmpresa = empresa.IdEmpresa,
Nombre = empresa.Nombre,
Detalle = empresa.Detalle
};
}
public async Task<(EmpresaDto? Empresa, string? Error)> CrearAsync(CreateEmpresaDto createDto, int idUsuario)
{
// Validación de negocio: Nombre duplicado
if (await _empresaRepository.ExistsByNameAsync(createDto.Nombre))
{
return (null, "El nombre de la empresa ya existe.");
}
var nuevaEmpresa = new Empresa
{
Nombre = createDto.Nombre,
Detalle = createDto.Detalle
};
// --- Transacción ---
using (var connection = _connectionFactory.CreateConnection())
{
// Abrir conexión de forma asíncrona
if (connection is System.Data.Common.DbConnection dbConnection)
{
await dbConnection.OpenAsync();
}
else
{
connection.Open(); // Fallback síncrono
}
using (var transaction = connection.BeginTransaction())
{
try
{
// 1. Crear Empresa (Repo maneja su historial dentro de esta transacción)
var empresaCreada = await _empresaRepository.CreateAsync(nuevaEmpresa, idUsuario, transaction);
if (empresaCreada == null)
{
throw new InvalidOperationException("No se pudo crear la empresa en el repositorio.");
}
// 2. Obtener IDs de Distribuidores
var distribuidoresIds = await _saldoRepository.GetAllDistribuidorIdsAsync(); // No necesita transacción si solo lee
// 3. Crear Saldos Iniciales (CERO) para cada distribuidor en esta nueva empresa
foreach (var idDistribuidor in distribuidoresIds)
{
bool saldoCreado = await _saldoRepository.CreateSaldoInicialAsync("Distribuidores", idDistribuidor, empresaCreada.IdEmpresa, transaction);
if (!saldoCreado)
{
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);
}
transaction.Commit();
var empresaDto = new EmpresaDto
{
IdEmpresa = empresaCreada.IdEmpresa,
Nombre = empresaCreada.Nombre,
Detalle = empresaCreada.Detalle
};
_logger.LogInformation("Empresa ID {IdEmpresa} creada exitosamente por Usuario ID {IdUsuario}.", empresaCreada.IdEmpresa, idUsuario);
return (empresaDto, null); // Éxito
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error al intentar hacer rollback en CrearAsync Empresa."); }
_logger.LogError(ex, "Error en transacción CrearAsync para Empresa. Nombre: {Nombre}", createDto.Nombre);
return (null, "Error interno al procesar la creación de la empresa.");
}
} // La transacción se dispone aquí (y cierra la conexión si no hubo commit/rollback explícito, aunque ya lo hacemos)
} // La conexión se cierra/dispone aquí
// --- Fin Transacción ---
}
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.");
}
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;
// --- 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())
{
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
}
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);
return (false, "Error interno al actualizar la empresa.");
}
}
}
// --- Fin Transacción ---
}
public async Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario)
{
// Primero verificamos si existe, incluso inactiva, para evitar errores 404 si no existe
var empresaExistente = await _empresaRepository.GetByIdAsync(id);
if (empresaExistente == null)
{
return (false, "Empresa no encontrada.");
}
// Validación: ¿Está en uso?
if (await _empresaRepository.IsInUseAsync(id))
{
return (false, "No se puede eliminar. Existen publicaciones relacionadas a la empresa.");
}
// --- 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())
{
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);
}
// 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.");
}
transaction.Commit();
_logger.LogInformation("Empresa ID {IdEmpresa} eliminada 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 EliminarAsync Empresa."); }
_logger.LogError(ex, "Error en transacción EliminarAsync para Empresa ID: {Id}", id);
return (false, "Error interno al eliminar la empresa.");
}
}
}
// --- Fin Transacción ---
}
}
}

15
Backend/GestionIntegral.Api/Services/Distribucion/IEmpresaService.cs Normal file
View File

@@ -0,0 +1,15 @@
using GestionIntegral.Api.Dtos.Empresas; // DTOs de Empresas
using System.Collections.Generic;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Services.Distribucion
{
public interface IEmpresaService
{
Task<IEnumerable<EmpresaDto>> ObtenerTodasAsync(string? nombreFilter, string? detalleFilter);
Task<EmpresaDto?> ObtenerPorIdAsync(int id);
Task<(EmpresaDto? Empresa, string? Error)> CrearAsync(CreateEmpresaDto createDto, int idUsuario);
Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdateEmpresaDto updateDto, int idUsuario);
Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario);
}
}

15
Backend/GestionIntegral.Api/Services/Distribucion/IZonaService.cs Normal file
View File

@@ -0,0 +1,15 @@
using GestionIntegral.Api.Dtos.Zonas; // Para los DTOs de Zonas
using System.Collections.Generic;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Services.Distribucion
{
public interface IZonaService
{
Task<IEnumerable<ZonaDto>> ObtenerTodasAsync(string? nombreFilter, string? descripcionFilter);
Task<ZonaDto?> ObtenerPorIdAsync(int id);
Task<(ZonaDto? Zona, string? Error)> CrearAsync(CreateZonaDto createDto, int idUsuario);
Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdateZonaDto updateDto, int idUsuario);
Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario); // Eliminar lógico (cambiar estado)
}
}

146
Backend/GestionIntegral.Api/Services/Distribucion/ZonaService.cs Normal file
View File

@@ -0,0 +1,146 @@
using GestionIntegral.Api.Data.Repositories; // Para IZonaRepository
using GestionIntegral.Api.Data.Repositories.Distribucion;
using GestionIntegral.Api.Dtos.Zonas;
using GestionIntegral.Api.Models.Distribucion; // Para Zona
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Services.Distribucion
{
public class ZonaService : IZonaService
{
private readonly IZonaRepository _zonaRepository;
private readonly ILogger<ZonaService> _logger;
public ZonaService(IZonaRepository zonaRepository, ILogger<ZonaService> logger)
{
_zonaRepository = zonaRepository;
_logger = logger;
}
public async Task<IEnumerable<ZonaDto>> ObtenerTodasAsync(string? nombreFilter, string? descripcionFilter)
{
var zonas = await _zonaRepository.GetAllAsync(nombreFilter, descripcionFilter, soloActivas: true); // Solo activas por defecto
// Mapeo Entidad -> DTO
return zonas.Select(z => new ZonaDto
{
IdZona = z.IdZona,
Nombre = z.Nombre,
Descripcion = z.Descripcion
});
}
public async Task<ZonaDto?> ObtenerPorIdAsync(int id)
{
var zona = await _zonaRepository.GetByIdAsync(id, soloActivas: true); // Solo activa por defecto
if (zona == null) return null;
// Mapeo Entidad -> DTO
return new ZonaDto
{
IdZona = zona.IdZona,
Nombre = zona.Nombre,
Descripcion = zona.Descripcion
};
}
public async Task<(ZonaDto? Zona, string? Error)> CrearAsync(CreateZonaDto createDto, int idUsuario)
{
// Validación: Nombre duplicado (entre zonas activas)
if (await _zonaRepository.ExistsByNameAsync(createDto.Nombre, null, soloActivas: true))
{
return (null, "El nombre de la zona ya existe.");
}
var nuevaZona = new Zona
{
Nombre = createDto.Nombre,
Descripcion = createDto.Descripcion,
Estado = true // Las zonas nuevas siempre están activas
};
var zonaCreada = await _zonaRepository.CreateAsync(nuevaZona, idUsuario);
if (zonaCreada == null)
{
_logger.LogError("Falló la creación de la Zona en el repositorio para el nombre: {Nombre}", createDto.Nombre);
return (null, "Error al crear la zona en la base de datos.");
}
// Mapeo de Entidad creada a DTO
var zonaDto = new ZonaDto
{
IdZona = zonaCreada.IdZona,
Nombre = zonaCreada.Nombre,
Descripcion = zonaCreada.Descripcion
};
return (zonaDto, null); // Éxito
}
public async Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdateZonaDto updateDto, int idUsuario)
{
// Verificar si la zona existe y está activa para poder modificarla (regla de negocio)
var zonaExistente = await _zonaRepository.GetByIdAsync(id, soloActivas: true);
if (zonaExistente == null)
{
// Podría no existir o estar inactiva
var zonaInactiva = await _zonaRepository.GetByIdAsync(id, soloActivas: false);
if (zonaInactiva != null)
return (false, "No se puede modificar una zona eliminada (inactiva).");
else
return (false, "Zona no encontrada.");
}
// Validación: Nombre duplicado (excluyendo el ID actual, entre zonas activas)
if (await _zonaRepository.ExistsByNameAsync(updateDto.Nombre, id, soloActivas: true))
{
return (false, "El nombre de la zona ya existe para otro registro activo.");
}
// Mapeo de DTO a Entidad para actualizar
zonaExistente.Nombre = updateDto.Nombre;
zonaExistente.Descripcion = updateDto.Descripcion;
// No modificamos el estado aquí, solo nombre y descripción
var actualizado = await _zonaRepository.UpdateAsync(zonaExistente, idUsuario);
if (!actualizado)
{
_logger.LogError("Falló la actualización de la Zona en el repositorio para el ID: {Id}", id);
return (false, "Error al actualizar la zona en la base de datos.");
}
return (true, null); // Éxito
}
public async Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario)
{
// Verificar si la zona existe (incluso si está inactiva, para evitar errores)
var zonaExistente = await _zonaRepository.GetByIdAsync(id, soloActivas: false);
if (zonaExistente == null)
{
return (false, "Zona no encontrada.");
}
// Si ya está inactiva, consideramos la operación exitosa (idempotencia)
if (!zonaExistente.Estado) {
return (true, null);
}
// Validación: No se puede eliminar si está en uso por distribuidores o canillas activos
if (await _zonaRepository.IsInUseAsync(id))
{
return (false, "No se puede eliminar. La zona está asignada a distribuidores o canillas activos.");
}
// Realizar el Soft Delete
var eliminado = await _zonaRepository.SoftDeleteAsync(id, idUsuario);
if (!eliminado)
{
_logger.LogError("Falló la eliminación lógica de la Zona en el repositorio para el ID: {Id}", id);
return (false, "Error al eliminar la zona de la base de datos.");
}
return (true, null); // Éxito
}
}
}

152
Backend/GestionIntegral.Api/Services/Impresion/EstadoBobinaService.cs Normal file
View File

@@ -0,0 +1,152 @@
using GestionIntegral.Api.Data;
using GestionIntegral.Api.Data.Repositories.Impresion;
using GestionIntegral.Api.Dtos.Impresion;
using GestionIntegral.Api.Models.Impresion;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Services.Impresion
{
public class EstadoBobinaService : IEstadoBobinaService
{
private readonly IEstadoBobinaRepository _estadoBobinaRepository;
private readonly DbConnectionFactory _connectionFactory;
private readonly ILogger<EstadoBobinaService> _logger;
public EstadoBobinaService(IEstadoBobinaRepository estadoBobinaRepository, DbConnectionFactory connectionFactory, ILogger<EstadoBobinaService> logger)
{
_estadoBobinaRepository = estadoBobinaRepository;
_connectionFactory = connectionFactory;
_logger = logger;
}
private EstadoBobinaDto MapToDto(EstadoBobina estadoBobina) => new EstadoBobinaDto
{
IdEstadoBobina = estadoBobina.IdEstadoBobina,
Denominacion = estadoBobina.Denominacion,
Obs = estadoBobina.Obs
};
public async Task<IEnumerable<EstadoBobinaDto>> ObtenerTodosAsync(string? denominacionFilter)
{
var estadosBobina = await _estadoBobinaRepository.GetAllAsync(denominacionFilter);
return estadosBobina.Select(MapToDto);
}
public async Task<EstadoBobinaDto?> ObtenerPorIdAsync(int id)
{
var estadoBobina = await _estadoBobinaRepository.GetByIdAsync(id);
return estadoBobina == null ? null : MapToDto(estadoBobina);
}
public async Task<(EstadoBobinaDto? EstadoBobina, string? Error)> CrearAsync(CreateEstadoBobinaDto createDto, int idUsuario)
{
if (await _estadoBobinaRepository.ExistsByDenominacionAsync(createDto.Denominacion))
{
return (null, "La denominación del estado de bobina ya existe.");
}
var nuevoEstado = new EstadoBobina { Denominacion = createDto.Denominacion, Obs = createDto.Obs };
using var connection = _connectionFactory.CreateConnection();
if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open();
using var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
var estadoCreado = await _estadoBobinaRepository.CreateAsync(nuevoEstado, idUsuario, transaction);
if (estadoCreado == null) throw new DataException("La creación en el repositorio devolvió null.");
transaction.Commit(); // Síncrono
_logger.LogInformation("EstadoBobina ID {IdEstadoBobina} creado por Usuario ID {IdUsuario}.", estadoCreado.IdEstadoBobina, idUsuario);
return (MapToDto(estadoCreado), null);
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error rollback CrearAsync EstadoBobina."); }
_logger.LogError(ex, "Error CrearAsync EstadoBobina. Denominación: {Denominacion}", createDto.Denominacion);
return (null, $"Error interno al crear el estado de bobina: {ex.Message}");
}
}
public async Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdateEstadoBobinaDto updateDto, int idUsuario)
{
if (await _estadoBobinaRepository.ExistsByDenominacionAsync(updateDto.Denominacion, id))
{
return (false, "La denominación del estado de bobina ya existe para otro registro.");
}
var estadoAActualizar = new EstadoBobina { IdEstadoBobina = id, Denominacion = updateDto.Denominacion, Obs = updateDto.Obs };
using var connection = _connectionFactory.CreateConnection();
if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open();
using var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
var actualizado = await _estadoBobinaRepository.UpdateAsync(estadoAActualizar, idUsuario, transaction);
if (!actualizado) throw new DataException("La operación de actualización no afectó ninguna fila.");
transaction.Commit(); // Síncrono
_logger.LogInformation("EstadoBobina ID {IdEstadoBobina} actualizado por Usuario ID {IdUsuario}.", id, idUsuario);
return (true, null);
}
catch (KeyNotFoundException knfex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error rollback ActualizarAsync EstadoBobina."); }
_logger.LogWarning(knfex, "Intento de actualizar EstadoBobina ID: {Id} no encontrado.", id);
return (false, "Estado de bobina no encontrado.");
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error rollback ActualizarAsync EstadoBobina."); }
_logger.LogError(ex, "Error ActualizarAsync EstadoBobina ID: {Id}", id);
return (false, $"Error interno al actualizar el estado de bobina: {ex.Message}");
}
}
public async Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario)
{
// Estados "fijos" como Disponible (1), En Uso (2), Dañada (3) probablemente no deberían eliminarse.
// Podrías añadir una validación aquí o en el repositorio si es necesario.
if (id <= 3) // Asumiendo IDs fijos para los estados base
{
return (false, "Los estados base (Disponible, En Uso, Dañada) no se pueden eliminar.");
}
if (await _estadoBobinaRepository.IsInUseAsync(id))
{
return (false, "No se puede eliminar. El estado de bobina está siendo utilizado en el stock.");
}
using var connection = _connectionFactory.CreateConnection();
if (connection is System.Data.Common.DbConnection dbConn) await dbConn.OpenAsync(); else connection.Open();
using var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
var eliminado = await _estadoBobinaRepository.DeleteAsync(id, idUsuario, transaction);
if (!eliminado) throw new DataException("La operación de eliminación no afectó ninguna fila.");
transaction.Commit(); // Síncrono
_logger.LogInformation("EstadoBobina ID {IdEstadoBobina} eliminado por Usuario ID {IdUsuario}.", id, idUsuario);
return (true, null);
}
catch (KeyNotFoundException knfex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error rollback EliminarAsync EstadoBobina."); }
_logger.LogWarning(knfex, "Intento de eliminar EstadoBobina ID: {Id} no encontrado.", id);
return (false, "Estado de bobina no encontrado.");
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error rollback EliminarAsync EstadoBobina."); }
_logger.LogError(ex, "Error EliminarAsync EstadoBobina ID: {Id}", id);
return (false, $"Error interno al eliminar el estado de bobina: {ex.Message}");
}
}
}
}

15
Backend/GestionIntegral.Api/Services/Impresion/IEstadoBobinaService.cs Normal file
View File

@@ -0,0 +1,15 @@
using GestionIntegral.Api.Dtos.Impresion;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Services.Impresion
{
public interface IEstadoBobinaService
{
Task<IEnumerable<EstadoBobinaDto>> ObtenerTodosAsync(string? denominacionFilter);
Task<EstadoBobinaDto?> ObtenerPorIdAsync(int id);
Task<(EstadoBobinaDto? EstadoBobina, string? Error)> CrearAsync(CreateEstadoBobinaDto createDto, int idUsuario);
Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdateEstadoBobinaDto updateDto, int idUsuario);
Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario);
}
}

15
Backend/GestionIntegral.Api/Services/Impresion/IPlantaService.cs Normal file
View File

@@ -0,0 +1,15 @@
using GestionIntegral.Api.Dtos.Impresion; // Para los DTOs
using System.Collections.Generic;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Services.Impresion
{
public interface IPlantaService
{
Task<IEnumerable<PlantaDto>> ObtenerTodasAsync(string? nombreFilter, string? detalleFilter);
Task<PlantaDto?> ObtenerPorIdAsync(int id);
Task<(PlantaDto? Planta, string? Error)> CrearAsync(CreatePlantaDto createDto, int idUsuario);
Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdatePlantaDto updateDto, int idUsuario);
Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario);
}
}

15
Backend/GestionIntegral.Api/Services/Impresion/ITipoBobinaService.cs Normal file
View File

@@ -0,0 +1,15 @@
using GestionIntegral.Api.Dtos.Impresion;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Services.Impresion
{
public interface ITipoBobinaService
{
Task<IEnumerable<TipoBobinaDto>> ObtenerTodosAsync(string? denominacionFilter);
Task<TipoBobinaDto?> ObtenerPorIdAsync(int id);
Task<(TipoBobinaDto? TipoBobina, string? Error)> CrearAsync(CreateTipoBobinaDto createDto, int idUsuario);
Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdateTipoBobinaDto updateDto, int idUsuario);
Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario);
}
}

185
Backend/GestionIntegral.Api/Services/Impresion/PlantaService.cs Normal file
View File

@@ -0,0 +1,185 @@
using GestionIntegral.Api.Data; // Para DbConnectionFactory
using GestionIntegral.Api.Data.Repositories.Impresion;
using GestionIntegral.Api.Dtos.Impresion;
using GestionIntegral.Api.Models.Impresion; // Para Planta
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System.Data; // Para IsolationLevel
using System.Linq;
using System.Threading.Tasks; // Todavía usamos async para operaciones de BD
namespace GestionIntegral.Api.Services.Impresion
{
public class PlantaService : IPlantaService
{
private readonly IPlantaRepository _plantaRepository;
private readonly DbConnectionFactory _connectionFactory; // Para manejar transacciones
private readonly ILogger<PlantaService> _logger;
public PlantaService(IPlantaRepository plantaRepository, DbConnectionFactory connectionFactory, ILogger<PlantaService> logger)
{
_plantaRepository = plantaRepository;
_connectionFactory = connectionFactory;
_logger = logger;
}
// Método para mapear Planta a PlantaDto
private PlantaDto MapToDto(Planta planta) => new PlantaDto
{
IdPlanta = planta.IdPlanta,
Nombre = planta.Nombre,
Detalle = planta.Detalle
};
public async Task<IEnumerable<PlantaDto>> ObtenerTodasAsync(string? nombreFilter, string? detalleFilter)
{
// Las operaciones de lectura no suelen necesitar transacción explícita aquí
var plantas = await _plantaRepository.GetAllAsync(nombreFilter, detalleFilter);
return plantas.Select(MapToDto);
}
public async Task<PlantaDto?> ObtenerPorIdAsync(int id)
{
var planta = await _plantaRepository.GetByIdAsync(id);
return planta == null ? null : MapToDto(planta);
}
public async Task<(PlantaDto? Planta, string? Error)> CrearAsync(CreatePlantaDto createDto, int idUsuario)
{
if (await _plantaRepository.ExistsByNameAsync(createDto.Nombre))
{
return (null, "El nombre de la planta ya existe.");
}
var nuevaPlanta = new Planta
{
Nombre = createDto.Nombre,
Detalle = createDto.Detalle
};
using var connection = _connectionFactory.CreateConnection();
// Abrir la conexión asíncronamente si es posible
if (connection is System.Data.Common.DbConnection dbConnection)
{
await dbConnection.OpenAsync();
}
else
{
connection.Open(); // Fallback síncrono
}
// Empezar transacción
using var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
var plantaCreada = await _plantaRepository.CreateAsync(nuevaPlanta, idUsuario, transaction);
if (plantaCreada == null)
{
throw new DataException("La creación en el repositorio devolvió null.");
}
transaction.Commit(); // <--- CORREGIDO: Commit síncrono
_logger.LogInformation("Planta ID {IdPlanta} creada exitosamente por Usuario ID {IdUsuario}.", plantaCreada.IdPlanta, idUsuario);
return (MapToDto(plantaCreada), null);
}
catch (Exception ex)
{
try
{
transaction.Rollback(); // <--- CORREGIDO: Rollback síncrono
}
catch (Exception rbEx)
{
_logger.LogError(rbEx, "Error adicional durante el rollback en CrearAsync Planta.");
}
_logger.LogError(ex, "Error en transacción CrearAsync para Planta. Nombre: {Nombre}", createDto.Nombre);
return (null, $"Error interno al crear la planta: {ex.Message}"); // Devolver mensaje de error
}
// La conexión y transacción se disponen automáticamente al salir del 'using'
}
public async Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdatePlantaDto updateDto, int idUsuario)
{
if (await _plantaRepository.ExistsByNameAsync(updateDto.Nombre, id))
{
return (false, "El nombre de la planta ya existe para otro registro.");
}
var plantaAActualizar = new Planta
{
IdPlanta = id,
Nombre = updateDto.Nombre,
Detalle = updateDto.Detalle
};
using var connection = _connectionFactory.CreateConnection();
if (connection is System.Data.Common.DbConnection dbConnection) { await dbConnection.OpenAsync(); } else { connection.Open(); }
using var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
var actualizado = await _plantaRepository.UpdateAsync(plantaAActualizar, idUsuario, transaction);
if (!actualizado)
{
// La excepción KeyNotFoundException se manejará en el bloque catch
// Aquí asumimos que si devuelve false es porque no afectó filas, lo cual podría ser un error lógico
throw new DataException("La operación de actualización no afectó ninguna fila.");
}
transaction.Commit(); // <--- CORREGIDO: Commit síncrono
_logger.LogInformation("Planta ID {IdPlanta} actualizada exitosamente por Usuario ID {IdUsuario}.", id, idUsuario);
return (true, null);
}
catch (KeyNotFoundException knfex) // Captura específica si el repo la lanza
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error adicional durante el rollback en ActualizarAsync Planta."); }
_logger.LogWarning(knfex, "Intento de actualizar Planta ID: {Id} no encontrada.", id);
return (false, "Planta no encontrada.");
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error adicional durante el rollback en ActualizarAsync Planta."); }
_logger.LogError(ex, "Error en transacción ActualizarAsync para Planta ID: {Id}", id);
return (false, $"Error interno al actualizar la planta: {ex.Message}");
}
}
public async Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario)
{
if (await _plantaRepository.IsInUseAsync(id))
{
return (false, "No se puede eliminar. La planta está siendo utilizada.");
}
using var connection = _connectionFactory.CreateConnection();
if (connection is System.Data.Common.DbConnection dbConnection) { await dbConnection.OpenAsync(); } else { connection.Open(); }
using var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
var eliminado = await _plantaRepository.DeleteAsync(id, idUsuario, transaction);
if (!eliminado)
{
throw new DataException("La operación de eliminación no afectó ninguna fila.");
}
transaction.Commit(); // <--- CORREGIDO: Commit síncrono
_logger.LogInformation("Planta ID {IdPlanta} eliminada exitosamente por Usuario ID {IdUsuario}.", id, idUsuario);
return (true, null);
}
catch (KeyNotFoundException knfex) // Captura específica si el repo la lanza
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error adicional durante el rollback en EliminarAsync Planta."); }
_logger.LogWarning(knfex, "Intento de eliminar Planta ID: {Id} no encontrada.", id);
return (false, "Planta no encontrada.");
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error adicional durante el rollback en EliminarAsync Planta."); }
_logger.LogError(ex, "Error en transacción EliminarAsync para Planta ID: {Id}", id);
return (false, $"Error interno al eliminar la planta: {ex.Message}");
}
}
}
}

144
Backend/GestionIntegral.Api/Services/Impresion/TipoBobinaService.cs Normal file
View File

@@ -0,0 +1,144 @@
using GestionIntegral.Api.Data;
using GestionIntegral.Api.Data.Repositories.Impresion;
using GestionIntegral.Api.Dtos.Impresion;
using GestionIntegral.Api.Models.Impresion;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
namespace GestionIntegral.Api.Services.Impresion
{
public class TipoBobinaService : ITipoBobinaService
{
private readonly ITipoBobinaRepository _tipoBobinaRepository;
private readonly DbConnectionFactory _connectionFactory;
private readonly ILogger<TipoBobinaService> _logger;
public TipoBobinaService(ITipoBobinaRepository tipoBobinaRepository, DbConnectionFactory connectionFactory, ILogger<TipoBobinaService> logger)
{
_tipoBobinaRepository = tipoBobinaRepository;
_connectionFactory = connectionFactory;
_logger = logger;
}
private TipoBobinaDto MapToDto(TipoBobina tipoBobina) => new TipoBobinaDto
{
IdTipoBobina = tipoBobina.IdTipoBobina,
Denominacion = tipoBobina.Denominacion
};
public async Task<IEnumerable<TipoBobinaDto>> ObtenerTodosAsync(string? denominacionFilter)
{
var tiposBobina = await _tipoBobinaRepository.GetAllAsync(denominacionFilter);
return tiposBobina.Select(MapToDto);
}
public async Task<TipoBobinaDto?> ObtenerPorIdAsync(int id)
{
var tipoBobina = await _tipoBobinaRepository.GetByIdAsync(id);
return tipoBobina == null ? null : MapToDto(tipoBobina);
}
public async Task<(TipoBobinaDto? TipoBobina, string? Error)> CrearAsync(CreateTipoBobinaDto createDto, int idUsuario)
{
if (await _tipoBobinaRepository.ExistsByDenominacionAsync(createDto.Denominacion))
{
return (null, "La denominación del tipo de bobina ya existe.");
}
var nuevoTipoBobina = new TipoBobina { Denominacion = createDto.Denominacion };
using var connection = _connectionFactory.CreateConnection();
if (connection is System.Data.Common.DbConnection dbConnection) { await dbConnection.OpenAsync(); } else { connection.Open(); }
using var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
var tipoBobinaCreado = await _tipoBobinaRepository.CreateAsync(nuevoTipoBobina, idUsuario, transaction);
if (tipoBobinaCreado == null) throw new DataException("La creación en el repositorio devolvió null.");
transaction.Commit(); // Síncrono
_logger.LogInformation("TipoBobina ID {IdTipoBobina} creado por Usuario ID {IdUsuario}.", tipoBobinaCreado.IdTipoBobina, idUsuario);
return (MapToDto(tipoBobinaCreado), null);
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error adicional durante el rollback en CrearAsync TipoBobina."); }
_logger.LogError(ex, "Error en transacción CrearAsync para TipoBobina. Denominación: {Denominacion}", createDto.Denominacion);
return (null, $"Error interno al crear el tipo de bobina: {ex.Message}");
}
}
public async Task<(bool Exito, string? Error)> ActualizarAsync(int id, UpdateTipoBobinaDto updateDto, int idUsuario)
{
if (await _tipoBobinaRepository.ExistsByDenominacionAsync(updateDto.Denominacion, id))
{
return (false, "La denominación del tipo de bobina ya existe para otro registro.");
}
var tipoBobinaAActualizar = new TipoBobina { IdTipoBobina = id, Denominacion = updateDto.Denominacion };
using var connection = _connectionFactory.CreateConnection();
if (connection is System.Data.Common.DbConnection dbConnection) { await dbConnection.OpenAsync(); } else { connection.Open(); }
using var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
var actualizado = await _tipoBobinaRepository.UpdateAsync(tipoBobinaAActualizar, idUsuario, transaction);
if (!actualizado) throw new DataException("La operación de actualización no afectó ninguna fila.");
transaction.Commit(); // Síncrono
_logger.LogInformation("TipoBobina ID {IdTipoBobina} actualizado por Usuario ID {IdUsuario}.", id, idUsuario);
return (true, null);
}
catch (KeyNotFoundException knfex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error adicional durante el rollback en ActualizarAsync TipoBobina."); }
_logger.LogWarning(knfex, "Intento de actualizar TipoBobina ID: {Id} no encontrado.", id);
return (false, "Tipo de bobina no encontrado.");
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error adicional durante el rollback en ActualizarAsync TipoBobina."); }
_logger.LogError(ex, "Error en transacción ActualizarAsync para TipoBobina ID: {Id}", id);
return (false, $"Error interno al actualizar el tipo de bobina: {ex.Message}");
}
}
public async Task<(bool Exito, string? Error)> EliminarAsync(int id, int idUsuario)
{
if (await _tipoBobinaRepository.IsInUseAsync(id))
{
return (false, "No se puede eliminar. El tipo de bobina está siendo utilizado en el stock.");
}
using var connection = _connectionFactory.CreateConnection();
if (connection is System.Data.Common.DbConnection dbConnection) { await dbConnection.OpenAsync(); } else { connection.Open(); }
using var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
var eliminado = await _tipoBobinaRepository.DeleteAsync(id, idUsuario, transaction);
if (!eliminado) throw new DataException("La operación de eliminación no afectó ninguna fila.");
transaction.Commit(); // Síncrono
_logger.LogInformation("TipoBobina ID {IdTipoBobina} eliminado por Usuario ID {IdUsuario}.", id, idUsuario);
return (true, null);
}
catch (KeyNotFoundException knfex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error adicional durante el rollback en EliminarAsync TipoBobina."); }
_logger.LogWarning(knfex, "Intento de eliminar TipoBobina ID: {Id} no encontrado.", id);
return (false, "Tipo de bobina no encontrado.");
}
catch (Exception ex)
{
try { transaction.Rollback(); } catch (Exception rbEx) { _logger.LogError(rbEx, "Error adicional durante el rollback en EliminarAsync TipoBobina."); }
_logger.LogError(ex, "Error en transacción EliminarAsync para TipoBobina ID: {Id}", id);
return (false, $"Error interno al eliminar el tipo de bobina: {ex.Message}");
}
}
}
}