protected virtual void AntesDePersistirValidarRegistro(TRegistro registro, ParametrosDeNegocio parametros)
{
var negocio = NegociosDeSe.NegocioDeUnDtm(registro.GetType().FullName);
if (!Contexto.DatosDeConexion.CreandoModelo && (!parametros.Parametros.ContainsKey(NegociosDeSe.ValidarSeguridad) || (bool)parametros.Parametros[NegociosDeSe.ValidarSeguridad]))
{
ValidarPermisosDePersistencia(parametros.Operacion, negocio, registro);
}
if ((parametros.Operacion == enumTipoOperacion.Insertar || parametros.Operacion == enumTipoOperacion.Modificar) && registro.ImplementaNombre())
{
var propiedades = registro.PropiedadesDelObjeto();
foreach (var propiedad in propiedades)
{
if (propiedad.Name == nameof(INombre.Nombre))
{
if (((string)propiedad.GetValue(registro)).IsNullOrEmpty())
{
GestorDeErrores.Emitir($"El nombre del objeto {typeof(TRegistro).Name} es obligatorio");
}
break;
}
}
}
if (parametros.Operacion == enumTipoOperacion.Modificar || parametros.Operacion == enumTipoOperacion.Eliminar)
{
}
}
public List <TRegistro> LeerRegistros(int posicion, int cantidad, List <ClausulaDeFiltrado> filtros = null, List <ClausulaDeOrdenacion> orden = null, List <ClausulaDeJoin> joins = null, ParametrosDeNegocio parametros = null)
{
List <TRegistro> elementosDeBd;
if (parametros == null)
{
parametros = new ParametrosDeNegocio(enumTipoOperacion.LeerSinBloqueo);
}
IQueryable <TRegistro> registros = DefinirConsulta(posicion, cantidad, filtros, orden, joins, parametros);
if (!Contexto.HayTransaccion && parametros.Operacion == enumTipoOperacion.LeerSinBloqueo)
{
var transactionOptions = new System.Transactions.TransactionOptions();
transactionOptions.IsolationLevel = System.Transactions.IsolationLevel.ReadUncommitted;
using (var transactionScope = new System.Transactions.TransactionScope(System.Transactions.TransactionScopeOption.Required, transactionOptions))
{
elementosDeBd = parametros.LeerParaActualizar ? registros.ToList() : registros.AsNoTracking().ToList();
transactionScope.Complete();
}
}
else
{
elementosDeBd = parametros.LeerParaActualizar ? registros.ToList() : registros.AsNoTracking().ToList();
}
return(elementosDeBd);
}
protected virtual void DespuesDePersistir(TRegistro registro, ParametrosDeNegocio parametros)
{
var indice = typeof(TRegistro).FullName;
_CacheDeRecuentos[indice] = true;
var propiedades = registro.PropiedadesDelObjeto();
foreach (var propiedad in propiedades)
{
if (typeof(TRegistro).ImplementaNombre() && propiedad.Name == nameof(INombre.Nombre))
{
ServicioDeCaches.EliminarElemento(typeof(TRegistro).FullName, $"{nameof(INombre.Nombre)}-{registro.ValorPropiedad(nameof(INombre.Nombre))}-1");
ServicioDeCaches.EliminarElemento(typeof(TRegistro).FullName, $"{nameof(INombre.Nombre)}-{registro.ValorPropiedad(nameof(INombre.Nombre))}-0");
}
if (propiedad.Name == nameof(registro.Id))
{
ServicioDeCaches.EliminarElemento(typeof(TRegistro).FullName, $"{nameof(registro.Id)}-{registro.Id}-1");
ServicioDeCaches.EliminarElemento(typeof(TRegistro).FullName, $"{nameof(registro.Id)}-{registro.Id}-0");
}
}
ServicioDeCaches.EliminarCache($"{typeof(TRegistro).FullName}-ak");
}
protected virtual void AntesMapearRegistroParaModificar(TElemento elemento, ParametrosDeNegocio opciones)
{
if (elemento.Id == 0)
{
GestorDeErrores.Emitir($"No puede modificar un elemento {typeof(TElemento).Name} con id 0");
}
}
public void PersistirElementoDto(TElemento elementoDto, ParametrosDeNegocio parametros)
{
TRegistro registro = MapearRegistro(elementoDto, parametros);
PersistirRegistro(registro, parametros);
elementoDto.Id = registro.Id;
}
public void PersistirElementosDto(List <TElemento> elementosDto, ParametrosDeNegocio parametros)
{
foreach (var elementoDto in elementosDto)
{
PersistirElementoDto(elementoDto, parametros);
}
}
public TRegistro LeerRegistro(List <ClausulaDeFiltrado> filtros, ParametrosDeNegocio parametros, bool errorSiNoHay, bool errorSiHayMasDeUno)
{
List <TRegistro> registros = LeerRegistros(0, -1, filtros, null, null, parametros);
if (errorSiNoHay && registros.Count == 0)
{
GestorDeErrores.Emitir($"No se ha localizado el registro solicitada para los filtros indicados en la clase {typeof(TRegistro).Name}");
}
if (errorSiHayMasDeUno && registros.Count > 1)
{
GestorDeErrores.Emitir($"Hay más de un registro para los filtros indicados en la clase {typeof(TRegistro).Name}");
}
if (registros.Count == 0)
{
return(null);
}
if (registros.Count > 1)
{
return(registros[0]);
}
return(registros[0]);
}
protected virtual void AntesMapearRegistroParaInsertar(TElemento elemento, ParametrosDeNegocio opciones)
{
if (elemento.Id > 0)
{
GestorDeErrores.Emitir($"No puede crear un elemento {typeof(TElemento).Name} con id {elemento.Id}");
}
}
protected bool HacerJoinCon(ParametrosDeNegocio parametros, string join)
{
if (!parametros.Parametros.ContainsKey(join))
{
return(true);
}
return((bool)parametros.Parametros[join]);
}
protected async Task ModificarRegistroAsync(TRegistro registro, ParametrosDeNegocio parametros = null)
{
if (parametros == null)
{
parametros = new ParametrosDeNegocio(enumTipoOperacion.Modificar);
}
Contexto.Update(registro);
await Contexto.SaveChangesAsync();
}
public async Task ModificarElementoAsync(TElemento elemento, ParametrosDeNegocio parametros = null)
{
if (parametros == null)
{
parametros = new ParametrosDeNegocio(enumTipoOperacion.Modificar);
}
TRegistro registro = MapearRegistro(elemento, parametros);
await ModificarRegistroAsync(registro);
}
public List <TRegistro> MapearRegistros(List <TElemento> elementos, ParametrosDeNegocio opciones)
{
var registros = new List <TRegistro>();
foreach (var elemento in elementos)
{
var registro = MapearRegistro(elemento, opciones);
registros.Add(registro);
}
return(registros);
}
public async Task InsertarElementoAsync(TElemento elemento, ParametrosDeNegocio parametros = null)
{
if (parametros == null)
{
parametros = new ParametrosDeNegocio(enumTipoOperacion.Insertar);
}
TRegistro elementoBD = MapearRegistro(elemento, parametros);
Contexto.Add(elementoBD);
await Contexto.SaveChangesAsync();
}
public TRegistro MapearRegistro(TElemento elemento, ParametrosDeNegocio opciones)
{
var registro = Mapeador.Map <TElemento, TRegistro>(elemento,
opt =>
{
opt.BeforeMap((src, dest) => AntesMapearRegistro(elemento, opciones));
opt.AfterMap((src, dest) => DespuesDeMapearRegistro(elemento, dest, opciones));
}
);
return(registro);
}
public TRegistro PersistirRegistro(TRegistro registro, ParametrosDeNegocio parametros)
{
if (parametros.Operacion != enumTipoOperacion.Insertar)
{
parametros.registroEnBd = LeerRegistroPorId(registro.Id, false, false, false, aplicarJoin: false);
}
var transaccion = Contexto.IniciarTransaccion();
try
{
AntesDePersistir(registro, parametros);
if (parametros.Operacion == enumTipoOperacion.Insertar)
{
Contexto.Add(registro);
}
else
if (parametros.Operacion == enumTipoOperacion.Modificar)
{
Contexto.Update(registro);
}
else
if (parametros.Operacion == enumTipoOperacion.Eliminar)
{
Contexto.Remove(registro);
}
else
{
throw new Exception($"Solo se pueden persistir operaciones del tipo {enumTipoOperacion.Insertar} o {enumTipoOperacion.Modificar} o {enumTipoOperacion.Eliminar}");
}
Contexto.SaveChanges();
if (Auditoria.ImplementaAuditoria(typeof(TRegistro)))
{
var negocio = NegociosDeSe.NegocioDeUnDtm(typeof(TRegistro).FullName);
var auditar = parametros.Operacion == enumTipoOperacion.Modificar ? parametros.registroEnBd : registro;
AuditoriaDeElementos.RegistrarAuditoria(Contexto, negocio, parametros.Operacion, (IElementoDtm)auditar);
}
DespuesDePersistir(registro, parametros);
Contexto.Commit(transaccion);
}
catch (Exception)
{
Contexto.Rollback(transaccion);
throw;
}
return(registro);
}
public int Contar(List <ClausulaDeFiltrado> filtros, List <ClausulaDeJoin> joins = null, ParametrosDeNegocio parametros = null)
{
if (parametros == null)
{
parametros = new ParametrosDeNegocio(enumTipoOperacion.Contar);
}
var registros = DefinirConsulta(0, -1, filtros, null, joins, parametros);
var total = registros.Count();
_CacheDeRecuentos[typeof(TRegistro).FullName] = false;
return(total);
}
private void AntesMapearRegistro(TElemento elemento, ParametrosDeNegocio opciones)
{
if (opciones.Operacion == enumTipoOperacion.Insertar)
{
AntesMapearRegistroParaInsertar(elemento, opciones);
}
else
if (opciones.Operacion == enumTipoOperacion.Modificar)
{
AntesMapearRegistroParaModificar(elemento, opciones);
}
else
if (opciones.Operacion == enumTipoOperacion.Eliminar)
{
AntesMapearRegistroParaEliminar(elemento, opciones);
}
}
protected void PersistirRegistros(List <TRegistro> registros, ParametrosDeNegocio parametros)
{
var transaccion = Contexto.IniciarTransaccion();
try
{
foreach (var registro in registros)
{
PersistirRegistro(registro, parametros);
}
Contexto.Commit(transaccion);
}
catch (Exception)
{
Contexto.Rollback(transaccion);
throw;
}
}
public TRegistro LeerUltimoRegistro(List <ClausulaDeFiltrado> filtros = null, List <ClausulaDeJoin> joins = null, ParametrosDeNegocio parametros = null)
{
if (parametros == null)
{
parametros = new ParametrosDeNegocio(enumTipoOperacion.LeerSinBloqueo);
}
var orden = new ClausulaDeOrdenacion()
{
OrdenarPor = nameof(IRegistro.Id), Modo = ModoDeOrdenancion.descendente
};
var registros = DefinirConsulta(0, -1, filtros, new List <ClausulaDeOrdenacion> {
orden
}, joins, parametros);
var registro = parametros.LeerParaActualizar ? registros.FirstOrDefault() : registros.AsNoTracking().FirstOrDefault();
return(registro);
}
public IEnumerable <TElemento> LeerElementos(int posicion, int cantidad, List <ClausulaDeFiltrado> filtros, List <ClausulaDeOrdenacion> orden, Dictionary <string, object> opcionesDeMapeo)
{
if (!opcionesDeMapeo.ContainsKey(nameof(ParametrosDeNegocio.Operacion)))
{
opcionesDeMapeo.Add(nameof(ParametrosDeNegocio.Operacion), enumTipoOperacion.LeerSinBloqueo.ToString());
}
var to = opcionesDeMapeo[nameof(ParametrosDeNegocio.Operacion)].ToTipoOperacion();
var aplicarJoin = opcionesDeMapeo.ContainsKey(nameof(ParametrosDeNegocio.AplicarJoin)) ? (bool)opcionesDeMapeo[nameof(ParametrosDeNegocio.AplicarJoin)] : true;
var p = new ParametrosDeNegocio(to, aplicarJoin);
List <TRegistro> elementosDeBd = LeerRegistros(posicion, cantidad, filtros, orden, null, p);
ParametrosDeMapeo parametrosDelMapeo = opcionesDeMapeo.Count > 0 ? new ParametrosDeMapeo()
{
Opciones = opcionesDeMapeo
} : null;
return(MapearElementos(elementosDeBd, parametrosDelMapeo));
}
public List <TRegistro> LeerRegistrosPorNombre(int posicion, int cantidad, List <ClausulaDeFiltrado> filtros = null, ParametrosDeNegocio parametros = null)
{
if (!typeof(TRegistro).ImplementaNombre())
{
throw new Exception($"se ha solicitado leer registros por nombre, el tipo {typeof(TRegistro).Name} no tiene dicho campo");
}
List <ClausulaDeOrdenacion> orden = new List <ClausulaDeOrdenacion>();
orden.Add(new ClausulaDeOrdenacion()
{
OrdenarPor = nameof(INombre.Nombre), Modo = ModoDeOrdenancion.ascendente
});
if (parametros == null)
{
parametros = new ParametrosDeNegocio(enumTipoOperacion.LeerSinBloqueo, aplicarJoin: false);
}
return(LeerRegistros(posicion, cantidad, filtros, orden, null, parametros));
}
protected virtual void AntesDePersistir(TRegistro registro, ParametrosDeNegocio parametros)
{
AntesDePersistirValidarRegistro(registro, parametros);
if (registro.ImplementaUnElemento())
{
var elemento = (IElementoDtm)registro;
if (parametros.Operacion == enumTipoOperacion.Insertar)
{
elemento.IdUsuaCrea = Contexto.DatosDeConexion.IdUsuario;
elemento.FechaCreacion = DateTime.Now;
}
else
if (parametros.Operacion == enumTipoOperacion.Modificar)
{
elemento.IdUsuaCrea = ((IElementoDtm)parametros.registroEnBd).IdUsuaCrea;
elemento.FechaCreacion = ((IElementoDtm)parametros.registroEnBd).FechaCreacion;
elemento.IdUsuaModi = Contexto.DatosDeConexion.IdUsuario;
elemento.FechaModificacion = DateTime.Now;
}
}
}
private List <TRegistro> LeerRegistroInterno(string propiedad, string valor, bool traqueado, bool ConBloqueo, bool aplicarJoin)
{
var filtro = new ClausulaDeFiltrado()
{
Criterio = CriteriosDeFiltrado.igual,
Clausula = propiedad,
Valor = valor
};
var filtros = new List <ClausulaDeFiltrado>()
{
filtro
};
var parametros = new ParametrosDeNegocio(ConBloqueo ? enumTipoOperacion.LeerConBloqueo : enumTipoOperacion.LeerSinBloqueo, aplicarJoin);
IQueryable <TRegistro> registros = DefinirConsulta(0, -1, filtros, null, null, parametros);
if (!traqueado)
{
return(registros.AsNoTracking().ToList());
}
return(registros.ToList());
}
protected virtual void DespuesDeMapearRegistro(TElemento elemento, TRegistro registro, ParametrosDeNegocio opciones)
{
if (enumTipoOperacion.Insertar == opciones.Operacion)
{
registro.Id = 0;
}
}
public int Recontar(List <ClausulaDeFiltrado> filtros, List <ClausulaDeJoin> joins = null, ParametrosDeNegocio parametros = null)
{
if (!_CacheDeRecuentos.ContainsKey(typeof(TRegistro).FullName) || _CacheDeRecuentos[typeof(TRegistro).FullName])
{
return(Contar(filtros, joins, parametros));
}
return(0);
}
protected virtual IQueryable <TRegistro> AplicarJoins(IQueryable <TRegistro> registros, List <ClausulaDeFiltrado> filtros, List <ClausulaDeJoin> joins, ParametrosDeNegocio parametros)
{
if (ApiDeRegistro.ImplementaUnElemento(typeof(TRegistro)) && HacerJoinCon(parametros, ltrJoinAudt.IncluirUsuarioDtm))
{
registros = registros.Include(e => ((IElementoDtm)e).UsuarioCreador);
registros = registros.Include(e => ((IElementoDtm)e).UsuarioModificador);
}
return(registros);
}
protected virtual IQueryable <TRegistro> AplicarFiltros(IQueryable <TRegistro> registros, List <ClausulaDeFiltrado> filtros, ParametrosDeNegocio parametros)
{
foreach (ClausulaDeFiltrado filtro in filtros)
{
if (filtro.Clausula.ToLower() == nameof(IRegistro.Id).ToLower() && filtro.Criterio == CriteriosDeFiltrado.igual)
{
HayFiltroPorId = filtro.Criterio == CriteriosDeFiltrado.igual;
return(registros.AplicarFiltroPorIdentificador(filtro, nameof(IRegistro.Id)));
}
}
return(registros.AplicarFiltroPorPropiedades(filtros));
}
private IQueryable <TRegistro> DefinirConsulta(int posicion, int cantidad, List <ClausulaDeFiltrado> filtros, List <ClausulaDeOrdenacion> orden, List <ClausulaDeJoin> joins, ParametrosDeNegocio parametros)
{
if (joins == null)
{
joins = new List <ClausulaDeJoin>();
}
if (filtros == null)
{
filtros = new List <ClausulaDeFiltrado>();
}
IQueryable <TRegistro> registros = Contexto.Set <TRegistro>();
if (parametros.AplicarJoin)
{
registros = AplicarJoins(registros, filtros, joins, parametros);
}
if (filtros.Count > 0)
{
registros = AplicarFiltros(registros, filtros, parametros);
}
if (parametros.Operacion == enumTipoOperacion.LeerSinBloqueo)
{
if (orden == null)
{
orden = new List <ClausulaDeOrdenacion>();
}
registros = AplicarOrden(registros, orden);
}
registros = registros.Skip(posicion);
if (cantidad > 0)
{
registros = registros.Take(cantidad);
}
return(registros);
}
public List <TElemento> ProyectarElementos(int posicion, int cantidad, List <ClausulaDeFiltrado> filtros, List <ClausulaDeOrdenacion> orden, ParametrosDeNegocio parametros = null)
{
IQueryable <TRegistro> registros = DefinirConsulta(posicion, cantidad, filtros, orden, null, parametros);
return(Mapeador.ProjectTo <TElemento>(registros).AsNoTracking().ToList());
}
