331 lines
16 KiB
C#
331 lines
16 KiB
C#
// src/Data/Repositories/PublicacionRepository.cs
|
|
using Dapper;
|
|
using GestionIntegral.Api.Models.Distribucion;
|
|
using Microsoft.Extensions.Logging;
|
|
using System; // Añadido para Exception
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
|
{
|
|
public class PublicacionRepository : IPublicacionRepository
|
|
{
|
|
private readonly DbConnectionFactory _connectionFactory;
|
|
private readonly ILogger<PublicacionRepository> _logger;
|
|
|
|
public PublicacionRepository(DbConnectionFactory connectionFactory, ILogger<PublicacionRepository> logger)
|
|
{
|
|
_connectionFactory = connectionFactory;
|
|
_logger = logger;
|
|
}
|
|
|
|
public async Task<IEnumerable<(Publicacion Publicacion, string NombreEmpresa)>> GetAllAsync(string? nombreFilter, int? idEmpresaFilter, bool? soloHabilitadas)
|
|
{
|
|
var sqlBuilder = new StringBuilder(@"
|
|
SELECT
|
|
p.Id_Publicacion AS IdPublicacion, p.Nombre, p.Observacion, p.Id_Empresa AS IdEmpresa,
|
|
p.CtrlDevoluciones, p.Habilitada,
|
|
e.Nombre AS NombreEmpresa
|
|
FROM dbo.dist_dtPublicaciones p
|
|
INNER JOIN dbo.dist_dtEmpresas e ON p.Id_Empresa = e.Id_Empresa
|
|
WHERE 1=1");
|
|
var parameters = new DynamicParameters();
|
|
|
|
if (soloHabilitadas.HasValue)
|
|
{
|
|
sqlBuilder.Append(soloHabilitadas.Value ? " AND (p.Habilitada = 1 OR p.Habilitada IS NULL)" : " AND p.Habilitada = 0");
|
|
}
|
|
if (!string.IsNullOrWhiteSpace(nombreFilter))
|
|
{
|
|
sqlBuilder.Append(" AND p.Nombre LIKE @NombreParam");
|
|
parameters.Add("NombreParam", $"%{nombreFilter}%");
|
|
}
|
|
if (idEmpresaFilter.HasValue && idEmpresaFilter > 0)
|
|
{
|
|
sqlBuilder.Append(" AND p.Id_Empresa = @IdEmpresaParam");
|
|
parameters.Add("IdEmpresaParam", idEmpresaFilter.Value);
|
|
}
|
|
sqlBuilder.Append(" ORDER BY p.Nombre;");
|
|
|
|
try
|
|
{
|
|
using var connection = _connectionFactory.CreateConnection();
|
|
var result = await connection.QueryAsync<Publicacion, string, (Publicacion, string)>(
|
|
sqlBuilder.ToString(),
|
|
(publicacion, nombreEmpresa) => (publicacion, nombreEmpresa),
|
|
parameters,
|
|
splitOn: "NombreEmpresa"
|
|
);
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error al obtener todas las Publicaciones. Filtros: Nombre='{NombreFilter}', IdEmpresa='{IdEmpresaFilter}', SoloHabilitadas='{SoloHabilitadas}'", nombreFilter, idEmpresaFilter, soloHabilitadas);
|
|
return Enumerable.Empty<(Publicacion, string)>();
|
|
}
|
|
}
|
|
|
|
public async Task<(Publicacion? Publicacion, string? NombreEmpresa)> GetByIdAsync(int id)
|
|
{
|
|
const string sql = @"
|
|
SELECT
|
|
p.Id_Publicacion AS IdPublicacion, p.Nombre, p.Observacion, p.Id_Empresa AS IdEmpresa,
|
|
p.CtrlDevoluciones, p.Habilitada,
|
|
e.Nombre AS NombreEmpresa
|
|
FROM dbo.dist_dtPublicaciones p
|
|
INNER JOIN dbo.dist_dtEmpresas e ON p.Id_Empresa = e.Id_Empresa
|
|
WHERE p.Id_Publicacion = @IdParam";
|
|
try
|
|
{
|
|
using var connection = _connectionFactory.CreateConnection();
|
|
var result = await connection.QueryAsync<Publicacion, string, (Publicacion?, string?)>(
|
|
sql,
|
|
(publicacion, nombreEmpresa) => (publicacion, nombreEmpresa),
|
|
new { IdParam = id },
|
|
splitOn: "NombreEmpresa"
|
|
);
|
|
return result.SingleOrDefault();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error al obtener Publicación por ID: {IdPublicacion}", id);
|
|
return (null, null);
|
|
}
|
|
}
|
|
|
|
public async Task<Publicacion?> GetByIdSimpleAsync(int id)
|
|
{
|
|
const string sql = @"
|
|
SELECT
|
|
Id_Publicacion AS IdPublicacion, Nombre, Observacion, Id_Empresa AS IdEmpresa,
|
|
CtrlDevoluciones, Habilitada
|
|
FROM dbo.dist_dtPublicaciones
|
|
WHERE Id_Publicacion = @IdParam";
|
|
try
|
|
{
|
|
using var connection = _connectionFactory.CreateConnection();
|
|
return await connection.QuerySingleOrDefaultAsync<Publicacion>(sql, new { IdParam = id });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error al obtener Publicación (simple) por ID: {IdPublicacion}", id);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public async Task<bool> ExistsByNameAndEmpresaAsync(string nombre, int idEmpresa, int? excludeIdPublicacion = null)
|
|
{
|
|
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtPublicaciones WHERE Nombre = @NombreParam AND Id_Empresa = @IdEmpresaParam");
|
|
var parameters = new DynamicParameters();
|
|
parameters.Add("NombreParam", nombre);
|
|
parameters.Add("IdEmpresaParam", idEmpresa);
|
|
if (excludeIdPublicacion.HasValue)
|
|
{
|
|
sqlBuilder.Append(" AND Id_Publicacion != @ExcludeIdParam");
|
|
parameters.Add("ExcludeIdParam", excludeIdPublicacion.Value);
|
|
}
|
|
try
|
|
{
|
|
using var connection = _connectionFactory.CreateConnection();
|
|
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error en ExistsByNameAndEmpresaAsync. Nombre: {Nombre}, IdEmpresa: {IdEmpresa}", nombre, idEmpresa);
|
|
return true; // Asumir que existe en caso de error para prevenir duplicados
|
|
}
|
|
}
|
|
|
|
public async Task<bool> IsInUseAsync(int id)
|
|
{
|
|
using var connection = _connectionFactory.CreateConnection();
|
|
string[] checkQueries = {
|
|
"SELECT TOP 1 1 FROM dbo.dist_EntradasSalidas WHERE Id_Publicacion = @IdParam",
|
|
"SELECT TOP 1 1 FROM dbo.dist_EntradasSalidasCanillas WHERE Id_Publicacion = @IdParam",
|
|
"SELECT TOP 1 1 FROM dbo.dist_Precios WHERE Id_Publicacion = @IdParam",
|
|
"SELECT TOP 1 1 FROM dbo.dist_RecargoZona WHERE Id_Publicacion = @IdParam",
|
|
"SELECT TOP 1 1 FROM dbo.dist_PorcPago WHERE Id_Publicacion = @IdParam",
|
|
"SELECT TOP 1 1 FROM dbo.dist_PorcMonPagoCanilla WHERE Id_Publicacion = @IdParam",
|
|
"SELECT TOP 1 1 FROM dbo.dist_dtPubliSecciones WHERE Id_Publicacion = @IdParam",
|
|
"SELECT TOP 1 1 FROM dbo.bob_RegPublicaciones WHERE Id_Publicacion = @IdParam",
|
|
"SELECT TOP 1 1 FROM dbo.bob_StockBobinas WHERE Id_Publicacion = @IdParam"
|
|
};
|
|
try
|
|
{
|
|
foreach (var query in checkQueries)
|
|
{
|
|
if (await connection.ExecuteScalarAsync<int?>(query, new { IdParam = id }) == 1) return true;
|
|
}
|
|
return false;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error en IsInUseAsync para Publicacion ID: {IdPublicacion}", id);
|
|
return true; // Asumir en uso si hay error de BD
|
|
}
|
|
}
|
|
|
|
public async Task<Publicacion?> CreateAsync(Publicacion nuevaPublicacion, int idUsuario, IDbTransaction transaction)
|
|
{
|
|
nuevaPublicacion.Habilitada ??= true;
|
|
|
|
const string sqlInsert = @"
|
|
INSERT INTO dbo.dist_dtPublicaciones (Nombre, Observacion, Id_Empresa, CtrlDevoluciones, Habilitada)
|
|
OUTPUT INSERTED.Id_Publicacion AS IdPublicacion, INSERTED.Nombre, INSERTED.Observacion, INSERTED.Id_Empresa AS IdEmpresa, INSERTED.CtrlDevoluciones, INSERTED.Habilitada
|
|
VALUES (@Nombre, @Observacion, @IdEmpresa, @CtrlDevoluciones, @Habilitada);";
|
|
|
|
var connection = transaction.Connection!;
|
|
var inserted = await connection.QuerySingleAsync<Publicacion>(sqlInsert, nuevaPublicacion, transaction);
|
|
if (inserted == null || inserted.IdPublicacion == 0) throw new DataException("Error al crear la publicación o al obtener el ID generado.");
|
|
|
|
const string sqlInsertHistorico = @"
|
|
INSERT INTO dbo.dist_dtPublicaciones_H
|
|
(Id_Publicacion, Nombre, Observacion, Id_Empresa, Habilitada, Id_Usuario, FechaMod, TipoMod)
|
|
VALUES (@IdPublicacionParam, @NombreParam, @ObservacionParam, @IdEmpresaParam, @HabilitadaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
|
|
|
|
await connection.ExecuteAsync(sqlInsertHistorico, new
|
|
{
|
|
IdPublicacionParam = inserted.IdPublicacion,
|
|
NombreParam = inserted.Nombre,
|
|
ObservacionParam = inserted.Observacion,
|
|
IdEmpresaParam = inserted.IdEmpresa,
|
|
HabilitadaParam = inserted.Habilitada ?? true,
|
|
IdUsuarioParam = idUsuario, // Renombrado para claridad con el parámetro de la función
|
|
FechaModParam = DateTime.Now,
|
|
TipoModParam = "Creada"
|
|
}, transaction);
|
|
return inserted;
|
|
}
|
|
|
|
public async Task<bool> UpdateAsync(Publicacion publicacionAActualizar, int idUsuario, IDbTransaction transaction)
|
|
{
|
|
var connection = transaction.Connection!;
|
|
var actual = await connection.QuerySingleOrDefaultAsync<Publicacion>(
|
|
@"SELECT Id_Publicacion AS IdPublicacion, Nombre, Observacion, Id_Empresa AS IdEmpresa, CtrlDevoluciones, Habilitada
|
|
FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdPublicacionParam", // Usar alias
|
|
new { IdPublicacionParam = publicacionAActualizar.IdPublicacion }, transaction);
|
|
if (actual == null) throw new KeyNotFoundException("Publicación no encontrada.");
|
|
|
|
publicacionAActualizar.Habilitada ??= true;
|
|
|
|
const string sqlUpdate = @"
|
|
UPDATE dbo.dist_dtPublicaciones SET
|
|
Nombre = @Nombre, Observacion = @Observacion, Id_Empresa = @IdEmpresa,
|
|
CtrlDevoluciones = @CtrlDevoluciones, Habilitada = @Habilitada
|
|
WHERE Id_Publicacion = @IdPublicacion;"; // Usar nombres de propiedad del objeto
|
|
const string sqlInsertHistorico = @"
|
|
INSERT INTO dbo.dist_dtPublicaciones_H
|
|
(Id_Publicacion, Nombre, Observacion, Id_Empresa, Habilitada, Id_Usuario, FechaMod, TipoMod)
|
|
VALUES (@IdPublicacionParam, @NombreParam, @ObservacionParam, @IdEmpresaParam, @HabilitadaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
|
|
|
|
await connection.ExecuteAsync(sqlInsertHistorico, new
|
|
{
|
|
IdPublicacionParam = actual.IdPublicacion,
|
|
NombreParam = actual.Nombre, // Valor ANTES de la actualización
|
|
ObservacionParam = actual.Observacion,
|
|
IdEmpresaParam = actual.IdEmpresa,
|
|
HabilitadaParam = actual.Habilitada ?? true,
|
|
IdUsuarioParam = idUsuario,
|
|
FechaModParam = DateTime.Now,
|
|
TipoModParam = "Actualizada"
|
|
}, transaction);
|
|
|
|
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, publicacionAActualizar, transaction);
|
|
return rowsAffected == 1;
|
|
}
|
|
|
|
public async Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction)
|
|
{
|
|
var connection = transaction.Connection!;
|
|
var actual = await connection.QuerySingleOrDefaultAsync<Publicacion>(
|
|
@"SELECT Id_Publicacion AS IdPublicacion, Nombre, Observacion, Id_Empresa AS IdEmpresa, CtrlDevoluciones, Habilitada
|
|
FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdParam", // Usar alias
|
|
new { IdParam = id }, transaction);
|
|
if (actual == null) throw new KeyNotFoundException("Publicación no encontrada.");
|
|
|
|
const string sqlDelete = "DELETE FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdParam";
|
|
const string sqlInsertHistorico = @"
|
|
INSERT INTO dbo.dist_dtPublicaciones_H
|
|
(Id_Publicacion, Nombre, Observacion, Id_Empresa, Habilitada, Id_Usuario, FechaMod, TipoMod)
|
|
VALUES (@IdPublicacionParam, @NombreParam, @ObservacionParam, @IdEmpresaParam, @HabilitadaParam, @IdUsuarioParam, @FechaModParam, @TipoModParam);";
|
|
|
|
await connection.ExecuteAsync(sqlInsertHistorico, new
|
|
{
|
|
IdPublicacionParam = actual.IdPublicacion,
|
|
NombreParam = actual.Nombre,
|
|
ObservacionParam = actual.Observacion,
|
|
IdEmpresaParam = actual.IdEmpresa,
|
|
HabilitadaParam = actual.Habilitada ?? true,
|
|
IdUsuarioParam = idUsuario,
|
|
FechaModParam = DateTime.Now,
|
|
TipoModParam = "Eliminada"
|
|
}, transaction);
|
|
|
|
var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { IdParam = id }, transaction);
|
|
return rowsAffected == 1;
|
|
}
|
|
|
|
public async Task<IEnumerable<PublicacionDiaSemana>> GetConfiguracionDiasAsync(int idPublicacion)
|
|
{
|
|
const string sql = @"
|
|
SELECT IdPublicacionDia, Id_Publicacion AS IdPublicacion, DiaSemana, Activo
|
|
FROM dbo.dist_PublicacionDiaSemana
|
|
WHERE Id_Publicacion = @IdPublicacion AND Activo = 1;"; // Solo los activos
|
|
try
|
|
{
|
|
using var connection = _connectionFactory.CreateConnection();
|
|
return await connection.QueryAsync<PublicacionDiaSemana>(sql, new { IdPublicacion = idPublicacion });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error al obtener configuración de días para Publicacion ID: {IdPublicacion}", idPublicacion);
|
|
return Enumerable.Empty<PublicacionDiaSemana>();
|
|
}
|
|
}
|
|
|
|
public async Task<IEnumerable<int>> GetPublicacionesIdsPorDiaSemanaAsync(byte diaSemana)
|
|
{
|
|
const string sql = @"
|
|
SELECT pds.Id_Publicacion
|
|
FROM dbo.dist_PublicacionDiaSemana pds
|
|
INNER JOIN dbo.dist_dtPublicaciones p ON pds.Id_Publicacion = p.Id_Publicacion
|
|
WHERE pds.DiaSemana = @DiaSemana AND pds.Activo = 1 AND (p.Habilitada = 1 OR p.Habilitada IS NULL);"; // Solo publicaciones habilitadas
|
|
try
|
|
{
|
|
using var connection = _connectionFactory.CreateConnection();
|
|
return await connection.QueryAsync<int>(sql, new { DiaSemana = diaSemana });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error al obtener IDs de publicaciones por día de semana: {DiaSemana}", diaSemana);
|
|
return Enumerable.Empty<int>();
|
|
}
|
|
}
|
|
|
|
public async Task UpdateConfiguracionDiasAsync(int idPublicacion, IEnumerable<byte> diasActivos, IDbTransaction transaction)
|
|
{
|
|
var connection = transaction.Connection!;
|
|
|
|
// 1. Eliminar configuraciones existentes para esta publicación (más simple que hacer upserts complejos)
|
|
const string sqlDelete = "DELETE FROM dbo.dist_PublicacionDiaSemana WHERE Id_Publicacion = @IdPublicacion;";
|
|
await connection.ExecuteAsync(sqlDelete, new { IdPublicacion = idPublicacion }, transaction);
|
|
|
|
// 2. Insertar las nuevas configuraciones activas
|
|
if (diasActivos != null && diasActivos.Any())
|
|
{
|
|
const string sqlInsert = @"
|
|
INSERT INTO dbo.dist_PublicacionDiaSemana (Id_Publicacion, DiaSemana, Activo)
|
|
VALUES (@IdPublicacion, @DiaSemana, 1);"; // Siempre activo al insertar
|
|
|
|
var insertTasks = diasActivos.Select(dia =>
|
|
connection.ExecuteAsync(sqlInsert, new { IdPublicacion = idPublicacion, DiaSemana = dia }, transaction)
|
|
);
|
|
await Task.WhenAll(insertTasks);
|
|
}
|
|
// No se necesita historial para esta tabla de configuración por ahora.
|
|
}
|
|
}
|
|
} |