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");
}
public static void ActualizarCachesDePermisos(ContextoSe contexto, IMapper mapeador, int idPermiso)
{
var gestorDePermisos = Gestor(contexto, mapeador);
if (idPermiso == 0)
{
ServicioDeCaches.EliminarCache($"{nameof(GestorDeVistaMvc)}.{nameof(GestorDeVistaMvc.TienePermisos)}");
ServicioDeCaches.EliminarCache($"{nameof(GestorDeElementos)}.{nameof(ValidarPermisosDePersistencia)}");
ServicioDeCaches.EliminarCache($"{nameof(GestorDeElementos)}.{nameof(LeerModoDeAccesoAlNegocio)}");
ServicioDeCaches.EliminarCache(nameof(GestorDeArbolDeMenu.LeerArbolDeMenu));
}
else
{
var permiso = gestorDePermisos.LeerRegistroPorId(idPermiso, true, false, false, aplicarJoin: true);
if (permiso.Clase.Nombre == ClaseDePermiso.ToString(enumClaseDePermiso.Vista))
{
ServicioDeCaches.EliminarCache(nameof(GestorDeArbolDeMenu.LeerArbolDeMenu));
}
if (permiso.Clase.Nombre == ClaseDePermiso.ToString(enumClaseDePermiso.Negocio))
{
ServicioDeCaches.EliminarCache($"{nameof(GestorDeElementos)}.{nameof(LeerModoDeAccesoAlNegocio)}");
}
var parteDeLaClave = $"Permiso:{idPermiso}";
ServicioDeCaches.EliminarElementos($"{nameof(GestorDeVistaMvc)}.{nameof(GestorDeVistaMvc.TienePermisos)}", parteDeLaClave);
ServicioDeCaches.EliminarElementos($"{nameof(GestorDeElementos)}.{nameof(ValidarPermisosDePersistencia)}", parteDeLaClave);
}
}
public static NegocioDtm LeerNegocioPorDtm(string elementoDtm)
{
var cache = ServicioDeCaches.Obtener($"{nameof(NegociosDeSe)}.{nameof(LeerNegocioPorDtm)}");
var indice = $"{nameof(Dtm)}-{elementoDtm}";
if (!cache.ContainsKey(indice))
{
var consulta = new ConsultaSql <NegocioDtm>(NegocioSqls.LeerNegocioPorDtm);
var valores = new Dictionary <string, object> {
{ $"@{nameof(elementoDtm)}", elementoDtm }
};
var negocios = consulta.LanzarConsulta(new DynamicParameters(valores));
if (negocios.Count > 1)
{
GestorDeErrores.Emitir($"No se ha localizado de forma unívoca el negocio al leer por dto {elementoDtm}");
}
if (negocios.Count == 0)
{
return(null);
}
cache[indice] = negocios[0];
}
return((NegocioDtm)cache[indice]);
}
protected override void DespuesDePersistir(NegocioDtm registro, ParametrosDeNegocio parametros)
{
base.DespuesDePersistir(registro, parametros);
if (parametros.Operacion == enumTipoOperacion.Modificar || parametros.Operacion == enumTipoOperacion.Eliminar)
{
var cache = $"{nameof(GestorDeElementos)}.{nameof(LeerModoDeAccesoAlNegocio)}";
var patron = $"Negocio:registro.Nombre";
ServicioDeCaches.EliminarElementos(cache, patron);
cache = $"{nameof(NegociosDeSe)}.{nameof(NegociosDeSe.LeerNegocioPorEnumerado)}";
var indice = $"{nameof(enumNegocio)}-{registro.Enumerado}";
ServicioDeCaches.EliminarElemento(cache, indice);
cache = $"{nameof(NegociosDeSe)}.{nameof(NegociosDeSe.LeerNegocioPorNombre)}";
indice = $"{nameof(INombre)}-{registro.Nombre}";
ServicioDeCaches.EliminarElemento(cache, indice);
cache = $"{nameof(NegociosDeSe)}.{nameof(NegociosDeSe.LeerNegocioPorDto)}";
indice = $"{nameof(NegociosDeSe.Dto)}-{registro.ElementoDto}";
ServicioDeCaches.EliminarElemento(cache, indice);
cache = $"{nameof(NegociosDeSe)}.{nameof(NegociosDeSe.LeerNegocioPorDtm)}";
indice = $"{nameof(NegociosDeSe.Dtm)}-{registro.ElementoDtm}";
ServicioDeCaches.EliminarElemento(cache, indice);
}
}
public static GestorDeElementos <TContexto, TRegistro, TElemento> Obtener(TContexto contexto, IMapper mapeador, string clase)
{
/*
* No puedo cachear el objeto gestorDeElementos ya que el contexto es disposable y si un proceso coge el objeto y otro hace un dispose de la conexión mientras se usa
* entonces fallaría el programa. Por tanto solo cacheo el objeto ConstructorInfo
*/
var cache = ServicioDeCaches.Obtener(nameof(Gestor));
clase = $"GestoresDeNegocio.{clase}";
if (!cache.ContainsKey(clase))
{
string ruta = Assembly.GetExecutingAssembly().GetName().CodeBase;
ruta = ruta.Substring(8); /* Quitamos FILE://// */
ruta = Path.GetDirectoryName(ruta);
var ensamblado = Assembly.LoadFrom(Path.Combine(ruta, "GestoresDeNegocio.dll"));
var type = ensamblado.GetType(clase);
List <Type> tipos = new List <Type> {
typeof(TContexto), typeof(IMapper)
};
var constructorSinParametros = type.GetConstructor(tipos.ToArray());
cache[clase] = constructorSinParametros;
}
return((GestorDeElementos <TContexto, TRegistro, TElemento>)((ConstructorInfo)cache[clase]).Invoke(new object[] { contexto, mapeador }));
// cache[clase] = constructorSinParametros.Invoke(new object[] { contexto, mapeador });
////}
////else
//// ((GestorDeElementos<TContexto, TRegistro, TElemento>)cache[clase]).Contexto = contexto;
//return (GestorDeElementos<TContexto, TRegistro, TElemento>)cache[clase];
}
internal static ParametroDeNegocioDtm LeerParametro(ContextoSe contextoSe, int idNegocio, string parametro, bool emitirErrorSiNoExiste)
{
var indice = $"{idNegocio}-{nameof(ParametroDeNegocioDtm.Nombre)}-{parametro}";
var cache = ServicioDeCaches.Obtener(typeof(ParametroDeNegocioDtm).FullName);
if (cache.ContainsKey(indice))
{
return((ParametroDeNegocioDtm)cache[indice]);
}
var gestor = Gestor(contextoSe, contextoSe.Mapeador);
var filtroPorNegocio = new ClausulaDeFiltrado(nameof(ParametroDeNegocioDtm.IdNegocio), CriteriosDeFiltrado.igual, idNegocio.ToString());
var filtroPorParametro = new ClausulaDeFiltrado(nameof(ParametroDeNegocioDtm.Nombre), CriteriosDeFiltrado.igual, parametro.ToString());
var registros = gestor.LeerRegistros(0, 2, new List <ClausulaDeFiltrado> {
filtroPorNegocio, filtroPorParametro
});
if (registros.Count != 1)
{
GestorDeErrores.Emitir($"La informaciónal leer el parametro {parametro} del negocio con id {idNegocio} no es correcta");
}
cache[indice] = registros[0];
return((ParametroDeNegocioDtm)cache[indice]);
}
public bool TienePermisos(UsuarioDtm usuarioConectado, string vista)
{
if (usuarioConectado.EsAdministrador)
{
return(true);
}
var vistaDtm = LeerVistaMvc(vista);
var cache = ServicioDeCaches.Obtener($"{nameof(GestorDeVistaMvc)}.{nameof(TienePermisos)}");
var indice = $"Usuario:{usuarioConectado.Id} Permiso:{vistaDtm.IdPermiso}";
if (!cache.ContainsKey(indice))
{
var gestor = GestorDePermisosDeUnUsuario.Gestor(Contexto, Mapeador);
var filtros = new List <ClausulaDeFiltrado>
{
new ClausulaDeFiltrado {
Clausula = nameof(PermisosDeUnUsuarioDtm.IdUsuario), Criterio = CriteriosDeFiltrado.igual, Valor = usuarioConectado.Id.ToString()
},
new ClausulaDeFiltrado {
Clausula = nameof(PermisosDeUnUsuarioDtm.IdPermiso), Criterio = CriteriosDeFiltrado.igual, Valor = vistaDtm.IdPermiso.ToString()
}
};
cache[indice] = gestor.Contar(filtros) > 0;
}
return((bool)cache[indice]);
}
protected override void DespuesDePersistir(ParametroDeNegocioDtm registro, ParametrosDeNegocio parametros)
{
base.DespuesDePersistir(registro, parametros);
if (parametros.Operacion == enumTipoOperacion.Modificar || parametros.Operacion == enumTipoOperacion.Eliminar)
{
ServicioDeCaches.EliminarElemento(typeof(ParametroDeNegocioDtm).FullName, $"{registro.IdNegocio}-{nameof(ParametroDeNegocioDtm.Nombre)}-{registro.Nombre}");
}
}
protected override void DespuesDePersistir(UsuarioDtm registro, ParametrosDeNegocio parametros)
{
base.DespuesDePersistir(registro, parametros);
if (parametros.Operacion != enumTipoOperacion.Insertar)
{
ServicioDeCaches.EliminarElemento(cache: typeof(UsuarioDtm).FullName, clave: $"{nameof(UsuarioDtm.Login)}-{registro.Login}-0");
ServicioDeCaches.EliminarElemento(cache: typeof(UsuarioDtm).FullName, clave: $"{nameof(UsuarioDtm.Login)}-{registro.Login}-1");
}
}
public enumModoDeAccesoDeDatos LeerModoDeAccesoAlNegocio(int idUsuario, enumNegocio negocio)
{
if (Contexto.DatosDeConexion.EsAdministrador)
{
return(enumModoDeAccesoDeDatos.Administrador);
}
if (NegociosDeSe.EsDeParametrizacion(negocio) && !Contexto.DatosDeConexion.EsAdministrador)
{
return(enumModoDeAccesoDeDatos.Consultor);
}
if (!NegociosDeSe.UsaSeguridad(negocio) || negocio == enumNegocio.No_Definido)
{
return(enumModoDeAccesoDeDatos.Administrador);
}
enumModoDeAccesoDeDatos modoDelUsuario = enumModoDeAccesoDeDatos.SinPermiso;
var cache = ServicioDeCaches.Obtener($"{nameof(GestorDeElementos)}.{nameof(LeerModoDeAccesoAlNegocio)}");
var indice = $"Usuario:{idUsuario} Negocio:{negocio.ToNombre()}";
if (!cache.ContainsKey(indice))
{
var modosLeidos = ModosDeAccesoAlNegocio(idUsuario, negocio);
foreach (var modoLeido in modosLeidos)
{
if (modoLeido.Administrador)
{
modoDelUsuario = enumModoDeAccesoDeDatos.Administrador;
break;
}
else
{
if (modoDelUsuario != enumModoDeAccesoDeDatos.Gestor && modoLeido.Gestor)
{
modoDelUsuario = enumModoDeAccesoDeDatos.Gestor;
}
else
if (modoLeido.Consultor && modoDelUsuario == enumModoDeAccesoDeDatos.SinPermiso)
{
modoDelUsuario = enumModoDeAccesoDeDatos.Consultor;
}
}
}
if (modoDelUsuario != enumModoDeAccesoDeDatos.SinPermiso && !NegocioActivo(negocio))
{
return(enumModoDeAccesoDeDatos.Consultor);
}
cache[indice] = modoDelUsuario;
}
return((enumModoDeAccesoDeDatos)cache[indice]);
}
public static Type ObtenerTypoDto(string tipoDto)
{
var cache = ServicioDeCaches.Obtener(nameof(ObtenerTypoDto));
if (!cache.ContainsKey(tipoDto))
{
cache[tipoDto] = Ensamblados.ObtenerType("ModeloDeDto.dll", tipoDto);
}
return((Type)cache[tipoDto]);
}
protected override void DespuesDePersistir(PuestosDeUnUsuarioDtm registro, ParametrosDeNegocio parametros)
{
base.DespuesDePersistir(registro, parametros);
if (parametros.Operacion == enumTipoOperacion.Modificar || parametros.Operacion == enumTipoOperacion.Eliminar)
{
var parteDeLaClave = $"Usuario:{registro.IdUsuario}";
ServicioDeCaches.EliminarElementos($"{nameof(GestorDeVistaMvc)}.{nameof(GestorDeVistaMvc.TienePermisos)}", parteDeLaClave);
ServicioDeCaches.EliminarElementos($"{nameof(GestorDeElementos)}.{nameof(ValidarPermisosDePersistencia)}", parteDeLaClave);
ServicioDeCaches.EliminarElementos($"{nameof(GestorDeElementos)}.{nameof(LeerModoDeAccesoAlNegocio)}", parteDeLaClave);
}
}
public static PropertyInfo[] PropiedadesDelObjeto(Type tipo)
{
var indice = tipo.FullName;
var cache = ServicioDeCaches.Obtener(nameof(Type.GetProperties));
if (!cache.ContainsKey(indice))
{
Type t = tipo.GetType();
cache[indice] = t.GetProperties();
}
PropertyInfo[] props = (PropertyInfo[])cache[indice];
return(props);
}
internal static VariableDtm LeerVariable(ContextoSe contextoSe, string variable, bool emitirErrorSiNoExiste)
{
var indice = $"{nameof(VariableDtm.Nombre)}-{variable}";
var cache = ServicioDeCaches.Obtener(typeof(VariableDtm).FullName);
if (cache.ContainsKey(indice))
{
return((VariableDtm)cache[indice]);
}
var gestor = Gestor(contextoSe, contextoSe.Mapeador);
var registro = gestor.LeerRegistroCacheado(nameof(VariableDtm.Nombre), variable, emitirErrorSiNoExiste, true, false);
return(registro);
}
public static TSource LeerCacheadoPorId <TSource>(this IQueryable <TSource> source, int id, bool errorSiNoHay = true) where TSource : Registro
{
var cache = ServicioDeCaches.Obtener(typeof(TSource).FullName);
var indice = $"{nameof(Registro.Id)}-{id}-0";
if (!cache.ContainsKey(indice))
{
var registro = source.FirstOrDefault(x => x.Id == id);
if (registro == null && errorSiNoHay)
{
GestorDeErrores.Emitir($"No se ha localizado el objeto con id {id} buscado en la entidad {typeof(TSource).Name}");
}
cache[indice] = registro;
}
return((TSource)cache[indice]);
}
public static IGestor CrearGestor(ContextoSe contexto, string dtm, string dto)
{
var cache = ServicioDeCaches.Obtener(nameof(CrearGestor));
var clave = $"{dtm}-{dto}";
if (!cache.ContainsKey(clave))
{
var assembly = Assembly.LoadFile($@"{Ensamblados.RutaDeBinarios()}\GestoresDeNegocio.dll");
var clases = assembly.GetExportedTypes();
for (int i = 0; i < clases.Length; i++)
{
var clase = clases[i];
if (clase.BaseType.Name.Contains(nameof(GestorDeElementos)) && clase.BaseType.GenericTypeArguments[1].Name == dtm && clase.BaseType.GenericTypeArguments[2].Name == dto)
{
var parametros = new Type[] { typeof(ContextoSe), typeof(IMapper) };
cache[clave] = clase.GetConstructor(new Type[] { typeof(ContextoSe), typeof(IMapper) });
if (cache[clave] == null)
{
throw new Exception($"No se ha definido el constructor Gestor para la clase {clase.Name} con los parámetros de contexto y mapeador.");
}
break;
}
if (clase.BaseType.Name.Contains("GestorDeRelaciones") && clase.BaseType.GenericTypeArguments[1].Name == dtm && clase.BaseType.GenericTypeArguments[2].Name == dto)
{
var parametros = new Type[] { typeof(ContextoSe), typeof(IMapper) };
cache[clave] = clase.GetConstructor(new Type[] { typeof(ContextoSe), typeof(IMapper) });
if (cache[clave] == null)
{
throw new Exception($"No se ha definido el constructor Gestor para la clase {clase.Name} con los parámetros de contexto y mapeador.");
}
break;
}
}
}
if (!cache.ContainsKey(clave))
{
throw new Exception($"No se ha localizado un gestor de elementods para los tipos {dtm}, {dto}.");
}
return((IGestor)((ConstructorInfo)cache[clave]).Invoke(new object[] { contexto, contexto.Mapeador }));
}
public TRegistro LeerRegistroCacheado(string propiedad, string valor, bool errorSiNoHay, bool errorSiHayMasDeUno, bool aplicarJoin)
{
var indice = $"{propiedad}-{valor}-{(!aplicarJoin ? "0" : "1")}";
var cache = ServicioDeCaches.Obtener(typeof(TRegistro).FullName);
if (!cache.ContainsKey(indice))
{
var a = LeerRegistro(propiedad, valor, errorSiNoHay, errorSiHayMasDeUno, traqueado: false, conBloqueo: false, aplicarJoin);
if (a == null)
{
return(null);
}
cache[indice] = a;
}
return((TRegistro)cache[indice]);
}
/*
* SELECT distinct T1.ID, T1.NOMBRE, T1.DESCRIPCION, T1.ICONO, T1.ACTIVO, T1.IDPADRE, T1.IDVISTA_MVC, T1.ORDEN, t4.NOMBRE as permiso, t5.NOMBRE as tipo, t6.NOMBRE as clase
* from ENTORNO.MENU t1
* inner join ENTORNO.VISTA_MVC t2 on t2.id = t1.IDVISTA_MVC
* inner join ENTORNO.USU_PERMISO t3 on t3.IDUSUA = 11 and t2.IDPERMISO = t3.IDPERMISO
* inner join SEGURIDAD.PERMISO t4 on t4.ID = t3.IDPERMISO
* inner join SEGURIDAD.TIPO_PERMISO t5 on t5.ID = t4.IDTIPO
* inner join SEGURIDAD.CLASE_PERMISO t6 on t6.ID = t4.IDCLASE
* where t1.IDVISTA_MVC is not null
* and t1.ACTIVO = 1
*/
public List <ArbolDeMenuDto> LeerArbolDeMenu(string usuario)
{
var gestor = GestorDeUsuarios.Gestor(Contexto, Mapeador);
var usuarioDtm = gestor.LeerRegistro(nameof(UsuarioDtm.Login), usuario, false, false, false, false, false);
if (usuarioDtm == null)
{
GestorDeErrores.Emitir($"Usuario {usuario} no válido");
}
var CacheArbolDeMenu = ServicioDeCaches.Obtener(nameof(this.LeerArbolDeMenu));
if (!CacheArbolDeMenu.ContainsKey(usuarioDtm.Id.ToString()))
{
var arbolDeMenu = Contexto
.MenuSe
.FromSqlInterpolated($@"
SELECT T1.ID,
T1.NOMBRE,
T1.DESCRIPCION,
T1.ICONO,
T1.ACTIVO,
T1.IDPADRE,
T1.IDVISTA_MVC,
T1.ORDEN,
T2.NOMBRE AS PADRE,
T3.NOMBRE AS VISTA,
T3.CONTROLADOR,
T3.ACCION,
T3.PARAMETROS
FROM ENTORNO.ARBOL_MENU_POR_USUARIO({usuarioDtm.Id}) AS T1
LEFT JOIN ENTORNO.MENU T2 ON T2.ID = T1.IDPADRE
LEFT JOIN ENTORNO.VISTA_MVC T3 ON T3.ID = T1.IDVISTA_MVC
order by t1.IDPADRE, T1.ORDEN, T1.NOMBRE").ToList();
//arbolDeMenu = LeerRegistros(0, -1);
var resultadoDto = new List <ArbolDeMenuDto>();
ProcesarSubMenus(resultadoDto, arbolDeMenu, padre: null);
CacheArbolDeMenu[usuarioDtm.Id.ToString()] = resultadoDto;
}
return((List <ArbolDeMenuDto>)CacheArbolDeMenu[usuarioDtm.Id.ToString()]);
}
public virtual void BorrarRegistros(IQueryable <TRegistro> registros)
{
var transaccion = Contexto.IniciarTransaccion();
try
{
Contexto.RemoveRange(registros);
Contexto.SaveChanges();
Contexto.Commit(transaccion);
}
catch (Exception)
{
Contexto.Rollback(transaccion);
throw;
}
finally
{
ServicioDeCaches.EliminarCache(typeof(TRegistro).FullName);
ServicioDeCaches.EliminarCache($"{typeof(TRegistro).FullName}-ak");
}
}
public VistaMvcDtm LeerVistaMvc(string vistaMvc)
{
var vista = ValidarParametroAntesDeLeerVistaMvc(vistaMvc);
var cache = ServicioDeCaches.Obtener(nameof(LeerVistaMvc));
if (!cache.ContainsKey(vista))
{
var filtros = new List <ClausulaDeFiltrado>
{
new ClausulaDeFiltrado {
Clausula = nameof(VistaMvcDtm.Controlador), Criterio = CriteriosDeFiltrado.igual, Valor = vista.Split(".")[0]
},
new ClausulaDeFiltrado {
Clausula = nameof(VistaMvcDtm.Accion), Criterio = CriteriosDeFiltrado.igual, Valor = vista.Split(".")[1]
}
};
var vistas = LeerRegistrosPorNombre(0, -1, filtros);
if (vistas.Count != 1)
{
if (vistas.Count == 0)
{
GestorDeErrores.Emitir($"No se ha localizado la vistaMvc {vista}");
}
else
{
GestorDeErrores.Emitir($"Se han localizado {vistas.Count} vistasMvc para {vista}");
}
}
if (vistas == null)
{
GestorDeErrores.Emitir($"Defina la vista {vista} en BD");
}
cache[$"{vista}"] = vistas[0];
}
return((VistaMvcDtm)cache[$"{vista}"]);
}
public static string UrlParaMostrarUnDto(Type claseDto)
{
var cache = ServicioDeCaches.Obtener(nameof(UrlParaMostrarUnDto));
if (!cache.ContainsKey(claseDto.FullName))
{
var consulta = new ConsultaSql <VistaMvcDtm>(VistaMvcSqls.LeerVistaPorDto);
var valores = new Dictionary <string, object> {
{ $"@{nameof(ElementoDto)}", claseDto.FullName }
};
var vistas = consulta.LanzarConsulta(new DynamicParameters(valores));
if (vistas.Count != 1)
{
GestorDeErrores.Emitir($"No se ha indicado la vista para mostrar el dto {claseDto.FullName}");
}
cache[claseDto.FullName] = $"{vistas[0].Controlador}/{vistas[0].Accion}";
}
return((string)cache[claseDto.FullName]);
}
public TRegistro LeerRegistroCacheado(List <ClausulaDeFiltrado> filtros, bool apliacarJoin, bool errorSiNoHay = true, bool errorSiHayMasDeUno = true)
{
string indice = "";
foreach (var filtro in filtros)
{
indice = indice.IsNullOrEmpty() ? filtro.Clausula : $"{indice}-{filtro.Clausula}";
}
var cache = ServicioDeCaches.Obtener($"{typeof(TRegistro).FullName}-ak");
if (!cache.ContainsKey(indice))
{
var registros = LeerRegistros(0, -1, filtros, null, null, new ParametrosDeNegocio(enumTipoOperacion.LeerSinBloqueo, apliacarJoin));
if (errorSiNoHay && registros.Count == 0)
{
GestorDeErrores.Emitir($"No se ha localizado el registro solicitada para el filtro proporcionado");
}
if (errorSiHayMasDeUno && registros.Count > 1)
{
GestorDeErrores.Emitir($"Hay más de un registro para el filtro proporcionado");
}
if (registros.Count == 0)
{
return(null);
}
if (registros.Count > 1)
{
return(registros[0]);
}
cache[indice] = registros[0];
}
return((TRegistro)cache[indice]);
}
public static NegocioDtm LeerNegocioPorEnumerado(enumNegocio negocio)
{
var cache = ServicioDeCaches.Obtener($"{nameof(NegociosDeSe)}.{nameof(LeerNegocioPorEnumerado)}");
var nombreEnumerado = negocio.ToString();
var indice = $"{nameof(enumNegocio)}-{nombreEnumerado}";
if (!cache.ContainsKey(indice))
{
var consulta = new ConsultaSql <NegocioDtm>(NegocioSqls.LeerNegocioPorEnumerado);
var valores = new Dictionary <string, object> {
{ $"@{nameof(NegocioDtm.Enumerado)}", nombreEnumerado }
};
var negocios = consulta.LanzarConsulta(new DynamicParameters(valores));
if (negocios.Count != 1)
{
GestorDeErrores.Emitir($"No se ha localizado de forma unívoca el negocio con el enumerado {nombreEnumerado}");
}
cache[indice] = negocios[0];
}
return((NegocioDtm)cache[indice]);
}
protected override void DespuesDePersistir(VistaMvcDtm registro, ParametrosDeNegocio parametros)
{
base.DespuesDePersistir(registro, parametros);
var RegistroEnBD = ((VistaMvcDtm)parametros.registroEnBd);
if (parametros.Operacion == enumTipoOperacion.Modificar && RegistroEnBD.Nombre != registro.Nombre)
{
GestorDePermisos.ModificarPermisoFuncional(Contexto, Mapeador, RegistroEnBD.Permiso, registro.Nombre, enumClaseDePermiso.Vista);
}
if (parametros.Operacion == enumTipoOperacion.Eliminar)
{
GestorDePermisos.Eliminar(Contexto, Mapeador, RegistroEnBD.Permiso);
}
if (parametros.Operacion == enumTipoOperacion.Eliminar || parametros.Operacion == enumTipoOperacion.Modificar)
{
ServicioDeCaches.EliminarElemento(nameof(LeerVistaMvc), $"{registro.Controlador}.{ registro.Accion}");
ServicioDeCaches.EliminarElemento(nameof(ExtensionesDto.UrlParaMostrarUnDto), registro.ElementoDto);
}
ServicioDeCaches.EliminarCache(nameof(GestorDeArbolDeMenu.LeerArbolDeMenu));
}
public static TSource LeerCacheadoPorPropiedad <TSource>(this IQueryable <TSource> source, string nombrePropiedad, string valor, bool errorSiNoHay = true, bool errorSiHayMasDeUno = true) where TSource : INombre
{
var cache = ServicioDeCaches.Obtener(typeof(TSource).FullName);
var indice = $"{nameof(INombre.Nombre)}-{nombrePropiedad}-0";
if (!cache.ContainsKey(indice))
{
var registros = source.Take(2).Where(x => x.Nombre.Equals(nombrePropiedad));
if (registros.Count() == 0 && errorSiNoHay)
{
GestorDeErrores.Emitir($"No se ha localizado el objeto con {nombrePropiedad} {valor} buscado en la entidad {typeof(TSource).Name}");
}
if (registros.Count() == 2 && errorSiHayMasDeUno)
{
GestorDeErrores.Emitir($"Hay más de un objeto con {nombrePropiedad} {valor} buscado en la entidad {typeof(TSource).Name}");
}
cache[indice] = registros.ToList()[0];
}
return((TSource)cache[indice]);
}
protected override void DespuesDePersistir(TipoDeViaDtm registro, ParametrosDeNegocio parametros)
{
base.DespuesDePersistir(registro, parametros);
ServicioDeCaches.EliminarElemento(typeof(TipoDeViaDtm).FullName, $"{nameof(TipoDeViaDtm.Sigla)}-{registro.ValorPropiedad(nameof(TipoDeViaDtm.Sigla))}-0");
}
public static void BorrarCache(string variable)
{
ServicioDeCaches.EliminarElemento(typeof(VariableDtm).FullName, variable);
}
protected override void DespuesDePersistir(MenuDtm registro, ParametrosDeNegocio parametros)
{
base.DespuesDePersistir(registro, parametros);
ServicioDeCaches.EliminarCache(nameof(GestorDeArbolDeMenu.LeerArbolDeMenu));
}
internal void LimpiarCacheDeArbolDeMenu()
{
ServicioDeCaches.EliminarCache(nameof(this.LeerArbolDeMenu));
}
public bool TienePermisos(UsuarioDtm usuarioConectado, enumModoDeAccesoDeDatos permisosNecesarios, enumNegocio negocio)
{
if (!NegociosDeSe.UsaSeguridad(negocio))
{
return(true);
}
var estaActivo = NegocioActivo(negocio);
if (!estaActivo && (permisosNecesarios == enumModoDeAccesoDeDatos.Administrador || permisosNecesarios == enumModoDeAccesoDeDatos.Gestor))
{
return(false);
}
if (usuarioConectado.EsAdministrador)
{
return(true);
}
if (negocio == enumNegocio.Variable)
{
switch (permisosNecesarios)
{
case enumModoDeAccesoDeDatos.Consultor: return(true);
case enumModoDeAccesoDeDatos.Administrador: return(Contexto.DatosDeConexion.EsAdministrador);
case enumModoDeAccesoDeDatos.Gestor: return(Contexto.DatosDeConexion.EsAdministrador);
default:
throw new Exception($"Al elemto variable no se le puede acceder con el tipo de permiso: '{permisosNecesarios}'");
}
}
var negocioDtm = LeerRegistroCacheado(nameof(NegocioDtm.Nombre), negocio.ToNombre(), errorSiNoHay: true, errorSiHayMasDeUno: true, aplicarJoin: false);
var cache = ServicioDeCaches.Obtener($"{nameof(GestorDeNegocios)}.{nameof(TienePermisos)}");
var indice = $"{usuarioConectado.Id}.{negocioDtm.Id}.{permisosNecesarios}";
if (!cache.ContainsKey(indice))
{
var gestor = GestorDePermisosDeUnUsuario.Gestor(Contexto, Mapeador);
var filtros = new List <ClausulaDeFiltrado>
{
new ClausulaDeFiltrado {
Clausula = nameof(PermisosDeUnUsuarioDtm.IdUsuario), Criterio = CriteriosDeFiltrado.igual, Valor = usuarioConectado.Id.ToString()
}
};
if (permisosNecesarios == enumModoDeAccesoDeDatos.Administrador)
{
filtros.Add(new ClausulaDeFiltrado {
Clausula = nameof(PermisosDeUnUsuarioDtm.IdPermiso), Criterio = CriteriosDeFiltrado.igual, Valor = negocioDtm.IdPermisoDeAdministrador.ToString()
});
}
if (permisosNecesarios == enumModoDeAccesoDeDatos.Gestor)
{
filtros.Add(new ClausulaDeFiltrado {
Clausula = nameof(PermisosDeUnUsuarioDtm.IdPermiso), Criterio = CriteriosDeFiltrado.esAlgunoDe, Valor = $"{negocioDtm.IdPermisoDeGestor},{negocioDtm.IdPermisoDeAdministrador}"
});
}
if (permisosNecesarios == enumModoDeAccesoDeDatos.Consultor)
{
filtros.Add(new ClausulaDeFiltrado {
Clausula = nameof(PermisosDeUnUsuarioDtm.IdPermiso), Criterio = CriteriosDeFiltrado.esAlgunoDe, Valor = $"{negocioDtm.IdPermisoDeConsultor},{negocioDtm.IdPermisoDeGestor},{negocioDtm.IdPermisoDeAdministrador}"
});
}
cache[indice] = gestor.Contar(filtros) > 0;
}
return((bool)cache[indice]);
}
