610 lines
17 KiB
C#
610 lines
17 KiB
C#
using System.ComponentModel.DataAnnotations;
|
|
using System.ComponentModel.DataAnnotations.Schema;
|
|
using System.Data;
|
|
using System.Linq.Expressions;
|
|
using System.Reflection;
|
|
using Dapper;
|
|
using MicroORM.Exceptions;
|
|
using MicroORM.Interfaces;
|
|
|
|
namespace MicroORM;
|
|
|
|
public class Repository<T>: IRepository<T>
|
|
{
|
|
private readonly Func<Task<IDbConnection>> _connectionFactory;
|
|
private IRepository<T> _repositoryImplementation;
|
|
|
|
public Repository(Func<Task<IDbConnection>> connectionFactory)
|
|
{
|
|
_connectionFactory = connectionFactory;
|
|
DapperTypeMapRegistrar.RegisterFor(typeof(T));
|
|
}
|
|
|
|
static Repository()
|
|
{
|
|
DapperTypeMapRegistrar.RegisterFor(typeof(T));
|
|
}
|
|
|
|
public async Task<int> SaveAsync<T>(T entity)
|
|
{
|
|
if (entity == null)
|
|
throw new ArgumentNullException(nameof(entity));
|
|
|
|
using var conn = await _connectionFactory();
|
|
await conn.EnsureOpenAsync();
|
|
using var tx = conn.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
await ResolveRelationsAsync(entity, conn, tx);
|
|
|
|
int id;
|
|
if (GetId(entity) == 0)
|
|
id = await InsertAsync(entity, conn, tx);
|
|
else
|
|
{
|
|
await UpdateAsync(entity, conn, tx);
|
|
id = GetId(entity);
|
|
}
|
|
|
|
tx.Commit();
|
|
return id;
|
|
}
|
|
catch
|
|
{
|
|
tx.Rollback();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
public async Task<IReadOnlyList<int>> SaveAsyncList<T>(IEnumerable<T> entities)
|
|
{
|
|
if (entities == null)
|
|
throw new ArgumentNullException(nameof(entities));
|
|
|
|
var list = entities as IList<T> ?? entities.ToList();
|
|
if (list.Count == 0)
|
|
return Array.Empty<int>();
|
|
|
|
using var conn = await _connectionFactory();
|
|
await conn.EnsureOpenAsync();
|
|
using var tx = conn.BeginTransaction();
|
|
|
|
try
|
|
{
|
|
var ids = new List<int>(list.Count);
|
|
|
|
foreach (var entity in list)
|
|
{
|
|
if (entity == null)
|
|
throw new OrmException("La lista contiene una entidad nula");
|
|
|
|
await ResolveRelationsAsync(entity, conn, tx);
|
|
|
|
int id;
|
|
if (GetId(entity) == 0)
|
|
{
|
|
id = await InsertAsync(entity, conn, tx);
|
|
SetId(entity, id); // MUY IMPORTANTE
|
|
}
|
|
else
|
|
{
|
|
await UpdateAsync(entity, conn, tx);
|
|
id = GetId(entity);
|
|
}
|
|
|
|
ids.Add(id);
|
|
}
|
|
|
|
tx.Commit();
|
|
return ids;
|
|
}
|
|
catch
|
|
{
|
|
tx.Rollback();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
|
|
public async Task<int> InsertAsync<T>(T entity, IDbConnection? connection = null, IDbTransaction? transaction = null)
|
|
{
|
|
if (entity == null)
|
|
throw new ArgumentNullException(nameof(entity));
|
|
|
|
bool ownsConnection = connection == null;
|
|
bool ownsTransaction = transaction == null;
|
|
|
|
IDbConnection? conn = connection;
|
|
IDbTransaction? tx = transaction;
|
|
|
|
try
|
|
{
|
|
var table = OrmMetadata.GetTableName<T>();
|
|
var key = OrmMetadata.GetKeyProperty<T>();
|
|
var props = OrmMetadata.GetScaffoldProperties<T>().Where(p => !OrmMetadata.IsIdentity(p)).ToArray();
|
|
|
|
if (!props.Any())
|
|
throw new OrmException($"No hay columnas insertables para {typeof(T).Name}");
|
|
|
|
var columns = props.Select(p => OrmMetadata.GetColumnName(p));
|
|
var parameters = props.Select(p => "@" + p.Name);
|
|
|
|
var sql = $@"
|
|
INSERT INTO {table}
|
|
({string.Join(", ", columns)})
|
|
VALUES ({string.Join(", ", parameters)})
|
|
RETURNING {OrmMetadata.GetColumnName(key)};
|
|
";
|
|
|
|
if (conn == null)
|
|
{
|
|
conn = await _connectionFactory();
|
|
await conn.EnsureOpenAsync();
|
|
}
|
|
|
|
if (tx == null)
|
|
{
|
|
tx = conn.BeginTransaction();
|
|
}
|
|
|
|
var id = await conn.ExecuteScalarAsync<int>(
|
|
sql,
|
|
entity,
|
|
tx
|
|
);
|
|
|
|
if (ownsTransaction)
|
|
tx.Commit();
|
|
|
|
return id;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (ownsTransaction)
|
|
try { tx?.Rollback(); } catch { /* swallow */ }
|
|
|
|
throw new OrmException(
|
|
$"Error INSERT en {typeof(T).Name}",
|
|
ex
|
|
);
|
|
}
|
|
finally
|
|
{
|
|
if (ownsTransaction)
|
|
tx?.Dispose();
|
|
|
|
if (ownsConnection)
|
|
conn?.Dispose();
|
|
}
|
|
}
|
|
|
|
public async Task<bool> UpdateAsync<T>(T entity, IDbConnection? connection = null, IDbTransaction? transaction = null)
|
|
{
|
|
if (entity == null)
|
|
throw new ArgumentNullException(nameof(entity));
|
|
|
|
bool ownsConnection = connection == null;
|
|
bool ownsTransaction = transaction == null;
|
|
|
|
IDbConnection? conn = connection;
|
|
IDbTransaction? tx = transaction;
|
|
|
|
try
|
|
{
|
|
var table = OrmMetadata.GetTableName<T>();
|
|
var key = OrmMetadata.GetKeyProperty<T>();
|
|
var keyValue = key.GetValue(entity);
|
|
|
|
if (keyValue == null)
|
|
throw new OrmException($"La entidad {typeof(T).Name} no tiene valor en la clave primaria");
|
|
|
|
var props = OrmMetadata.GetScaffoldProperties<T>().Where(p => !OrmMetadata.IsIdentity(p)).ToArray();
|
|
if (!props.Any())
|
|
return false;
|
|
|
|
var sets = props.Select(p =>
|
|
$"{OrmMetadata.GetColumnName(p)} = @{p.Name}");
|
|
|
|
var sql = $@"
|
|
UPDATE {table}
|
|
SET {string.Join(", ", sets)}
|
|
WHERE {OrmMetadata.GetColumnName(key)} = @{key.Name};
|
|
";
|
|
|
|
if (conn == null)
|
|
{
|
|
conn = await _connectionFactory();
|
|
await conn.EnsureOpenAsync();
|
|
}
|
|
|
|
if (tx == null)
|
|
{
|
|
tx = conn.BeginTransaction();
|
|
}
|
|
|
|
var affected = await conn.ExecuteAsync(
|
|
sql,
|
|
entity,
|
|
tx
|
|
);
|
|
|
|
if (ownsTransaction)
|
|
tx.Commit();
|
|
|
|
return affected > 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (ownsTransaction)
|
|
try { tx?.Rollback(); } catch { /* ignore */ }
|
|
|
|
throw new OrmException(
|
|
$"Error UPDATE en {typeof(T).Name}",
|
|
ex
|
|
);
|
|
}
|
|
finally
|
|
{
|
|
if (ownsTransaction)
|
|
tx?.Dispose();
|
|
|
|
if (ownsConnection)
|
|
conn?.Dispose();
|
|
}
|
|
}
|
|
|
|
public async Task<T?> GetByIdAsync(object id)
|
|
{
|
|
if (id == null)
|
|
throw new ArgumentNullException(nameof(id));
|
|
|
|
try
|
|
{
|
|
var table = OrmMetadata.GetTableName<T>();
|
|
var key = OrmMetadata.GetKeyProperty<T>();
|
|
|
|
var sql = $@"
|
|
SELECT *
|
|
FROM {table}
|
|
WHERE {OrmMetadata.GetColumnName(key)} = @Id;
|
|
";
|
|
|
|
using var conn = await _connectionFactory();
|
|
await conn.EnsureOpenAsync();
|
|
|
|
return await conn.QueryFirstOrDefaultAsync<T>(sql, new { Id = id });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new OrmException(
|
|
$"Error SELECT por ID en {typeof(T).Name}",
|
|
ex
|
|
);
|
|
}
|
|
}
|
|
|
|
public async Task<IEnumerable<T>> GetAllAsync(Expression<Func<T, bool>>? filter = null, Expression<Func<T, object>>? orderBy = null, bool descending = false)
|
|
{
|
|
try
|
|
{
|
|
var table = OrmMetadata.GetTableName<T>();
|
|
var parameters = new DynamicParameters();
|
|
|
|
var sql = $"SELECT * FROM {table}";
|
|
|
|
// WHERE dinámico
|
|
if (filter != null)
|
|
{
|
|
var where = ExpressionToSqlTranslator.Translate(filter, parameters);
|
|
sql += $" WHERE {where}";
|
|
}
|
|
|
|
// ORDER BY dinámico
|
|
if (orderBy != null)
|
|
{
|
|
var column = ExpressionToSqlTranslator.GetOrderByColumn(orderBy);
|
|
sql += $" ORDER BY {column} {(descending ? "DESC" : "ASC")}";
|
|
}
|
|
|
|
sql += ";";
|
|
|
|
using var conn = await _connectionFactory();
|
|
await conn.EnsureOpenAsync();
|
|
|
|
return await conn.QueryAsync<T>(sql, parameters);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new OrmException(
|
|
$"Error SELECT dinámico en {typeof(T).Name}",
|
|
ex
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public async Task<bool> DeleteAsync(object id)
|
|
{
|
|
if (id == null)
|
|
throw new ArgumentNullException(nameof(id));
|
|
|
|
try
|
|
{
|
|
var table = OrmMetadata.GetTableName<T>();
|
|
var key = OrmMetadata.GetKeyProperty<T>();
|
|
|
|
var sql = $@"
|
|
DELETE FROM {table}
|
|
WHERE {OrmMetadata.GetColumnName(key)} = @Id;
|
|
";
|
|
|
|
using var conn = await _connectionFactory();
|
|
await conn.EnsureOpenAsync();
|
|
|
|
return await conn.ExecuteAsync(sql, new { Id = id }) > 0;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new OrmException(
|
|
$"Error DELETE en {typeof(T).Name}",
|
|
ex
|
|
);
|
|
}
|
|
}
|
|
|
|
public async Task<T?> QuerySingleAsync<T>(string sql, object? parameters = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(sql))
|
|
throw new ArgumentException("SQL inválido", nameof(sql));
|
|
|
|
try
|
|
{
|
|
using var conn = await _connectionFactory();
|
|
await conn.EnsureOpenAsync();
|
|
|
|
return await conn.QueryFirstOrDefaultAsync<T>(
|
|
sql,
|
|
parameters
|
|
);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new OrmException(
|
|
$"Error en QuerySingle<{typeof(T).Name}>",
|
|
ex
|
|
);
|
|
}
|
|
}
|
|
|
|
public async Task<IEnumerable<T>> QueryAsync<T>(string sql, object? parameters = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(sql))
|
|
throw new ArgumentException("SQL inválido", nameof(sql));
|
|
|
|
try
|
|
{
|
|
using var conn = await _connectionFactory();
|
|
await conn.EnsureOpenAsync();
|
|
|
|
return await conn.QueryAsync<T>(sql, parameters);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new OrmException(
|
|
$"Error en Query<{typeof(T).Name}>",
|
|
ex
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
public async Task<T?> ExecuteScalarAsync<T>(string sql, object? parameters = null)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(sql))
|
|
throw new ArgumentException("SQL inválido", nameof(sql));
|
|
|
|
try
|
|
{
|
|
using var conn = await _connectionFactory();
|
|
await conn.EnsureOpenAsync();
|
|
|
|
return await conn.ExecuteScalarAsync<T>(
|
|
sql,
|
|
parameters
|
|
);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new OrmException(
|
|
$"Error en ExecuteScalar<{typeof(T).Name}>",
|
|
ex
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
private async Task ResolveRelationsAsync<T>(
|
|
T entity,
|
|
IDbConnection conn,
|
|
IDbTransaction tx)
|
|
{
|
|
var navProps = typeof(T)
|
|
.GetProperties()
|
|
.Where(p =>
|
|
p.PropertyType.IsClass &&
|
|
p.PropertyType != typeof(string) &&
|
|
p.GetCustomAttribute<NotMappedAttribute>() == null);
|
|
|
|
foreach (var nav in navProps)
|
|
{
|
|
var related = nav.GetValue(entity);
|
|
if (related == null)
|
|
continue;
|
|
|
|
var relatedType = nav.PropertyType;
|
|
var relatedId = GetId(related);
|
|
|
|
if (relatedId == 0)
|
|
relatedId = await InsertDynamicAsync(related, conn, tx);
|
|
else
|
|
await UpdateDynamicAsync(related, conn, tx);
|
|
|
|
SetForeignKey(entity, nav, relatedId);
|
|
}
|
|
}
|
|
|
|
private void SetForeignKey<T>(
|
|
T entity,
|
|
PropertyInfo navProp,
|
|
int fkValue)
|
|
{
|
|
var fkAttr = navProp.GetCustomAttribute<ForeignKeyAttribute>();
|
|
if (fkAttr != null)
|
|
{
|
|
var fkProp = typeof(T).GetProperty(fkAttr.Name);
|
|
fkProp?.SetValue(entity, fkValue);
|
|
return;
|
|
}
|
|
|
|
var fkName = navProp.Name + "Id";
|
|
var prop = typeof(T).GetProperty(fkName);
|
|
|
|
if (prop == null)
|
|
throw new OrmException($"No se pudo resolver FK para {navProp.Name}");
|
|
|
|
prop.SetValue(entity, fkValue);
|
|
}
|
|
|
|
|
|
private async Task<int> InsertDynamicAsync(
|
|
object entity,
|
|
IDbConnection conn,
|
|
IDbTransaction tx)
|
|
{
|
|
var method = typeof(Repository<>)
|
|
.GetMethod(nameof(InsertAsync))!
|
|
.MakeGenericMethod(entity.GetType());
|
|
|
|
return await (Task<int>)method.Invoke(this, new[] { entity, conn, tx })!;
|
|
}
|
|
|
|
|
|
private async Task<int> UpdateDynamicAsync(
|
|
object entity,
|
|
IDbConnection conn,
|
|
IDbTransaction tx)
|
|
{
|
|
var method = typeof(Repository<>)
|
|
.GetMethod(nameof(UpdateAsync))!
|
|
.MakeGenericMethod(entity.GetType());
|
|
|
|
return await (Task<int>)method.Invoke(this, new[] { entity, conn, tx })!;
|
|
}
|
|
|
|
|
|
private static int GetId(object entity)
|
|
{
|
|
if (entity == null) throw new ArgumentNullException(nameof(entity));
|
|
|
|
var type = entity.GetType();
|
|
|
|
var keyProp = type.GetProperties()
|
|
.FirstOrDefault(p => p.GetCustomAttribute<KeyAttribute>() != null);
|
|
|
|
if (keyProp == null)
|
|
{
|
|
keyProp = type.GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase)
|
|
?? type.GetProperty(type.Name + "Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
|
|
}
|
|
|
|
if (keyProp == null)
|
|
throw new OrmException($"No se encontró la propiedad clave (Key/Id/{type.Name}Id) en el tipo {type.FullName}");
|
|
|
|
var value = keyProp.GetValue(entity);
|
|
if (value == null) return 0;
|
|
if (value is int i) return i;
|
|
|
|
if (value is long l)
|
|
{
|
|
if (l > int.MaxValue || l < int.MinValue)
|
|
throw new OrmException($"El valor de la clave primaria ({l}) excede el rango de int para {type.FullName}");
|
|
return (int)l;
|
|
}
|
|
|
|
try
|
|
{
|
|
var converted = Convert.ToInt32(value);
|
|
return converted;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
if (value is Guid)
|
|
throw new OrmException($"La clave primaria de {type.FullName} es un GUID; el flujo actual espera claves numéricas. Ajusta el método si deseas soportar GUIDs.");
|
|
|
|
throw new OrmException($"No fue posible convertir la clave primaria de {type.FullName} (tipo {value.GetType().Name}) a int.");
|
|
}
|
|
}
|
|
|
|
private static void SetId(object entity, int id)
|
|
{
|
|
if (entity == null) throw new ArgumentNullException(nameof(entity));
|
|
|
|
var type = entity.GetType();
|
|
|
|
// Buscar la propiedad clave (igual que en GetId)
|
|
var keyProp = type.GetProperties()
|
|
.FirstOrDefault(p => p.GetCustomAttribute<KeyAttribute>() != null);
|
|
|
|
if (keyProp == null)
|
|
{
|
|
keyProp = type.GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase)
|
|
?? type.GetProperty(type.Name + "Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
|
|
}
|
|
|
|
if (keyProp == null)
|
|
throw new OrmException($"No se encontró la propiedad clave (Key/Id/{type.Name}Id) en el tipo {type.FullName}");
|
|
|
|
if (!keyProp.CanWrite)
|
|
throw new OrmException($"La propiedad clave {keyProp.Name} en {type.FullName} no tiene setter público.");
|
|
|
|
var targetType = Nullable.GetUnderlyingType(keyProp.PropertyType) ?? keyProp.PropertyType;
|
|
|
|
object valueToSet;
|
|
if (targetType == typeof(int))
|
|
{
|
|
valueToSet = id;
|
|
}
|
|
else if (targetType == typeof(long))
|
|
{
|
|
valueToSet = (long)id;
|
|
}
|
|
else if (targetType == typeof(short))
|
|
{
|
|
valueToSet = (short)id;
|
|
}
|
|
else if (targetType == typeof(byte))
|
|
{
|
|
valueToSet = (byte)id;
|
|
}
|
|
else if (targetType == typeof(Guid))
|
|
{
|
|
throw new OrmException($"La clave primaria de {type.FullName} es GUID; SetId con int no es aplicable.");
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
valueToSet = Convert.ChangeType(id, targetType);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw new OrmException($"No fue posible convertir int a {targetType.Name} para la clave de {type.FullName}.", ex);
|
|
}
|
|
}
|
|
|
|
keyProp.SetValue(entity, valueToSet);
|
|
}
|
|
} |