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]); }
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 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]); }
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]); }
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 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 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]); }
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]); }
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]); }