internal static IRegistro ObjetoDtm(this enumNegocio negocio) { switch (negocio) { case enumNegocio.Usuario: return(new UsuarioDtm()); case enumNegocio.VistaMvc: return(new VistaMvcDtm()); case enumNegocio.Variable: return(new VariableDtm()); case enumNegocio.Menu: return(new MenuDtm()); case enumNegocio.Puesto: return(new PuestoDtm()); case enumNegocio.Negocio: return(new NegocioDtm()); case enumNegocio.Permiso: return(new PermisoDtm()); case enumNegocio.Rol: return(new RolDtm()); case enumNegocio.Pais: return(new PaisDtm()); case enumNegocio.Provincia: return(new ProvinciaDtm()); case enumNegocio.Municipio: return(new MunicipioDtm()); case enumNegocio.Correo: return(new CorreoDtm()); } throw new Exception($"El negocio {negocio} no está definido, no se puede obtener un objeto dtm"); }
public static int ContarElementos(ContextoSe contexto, enumNegocio negocio, int idElemento, List <int> usuarios) { var a = new AuditoriaDeElementos(contexto, negocio); var cantidad = a.ContarRegistros(idElemento, usuarios); return(cantidad); }
protected virtual dynamic CargarLista(string claseElemento, enumNegocio negocio, List <ClausulaDeFiltrado> filtros) { //if (claseElemento == nameof(ExportacionDto)) // return GestorDeExportaciones.LeerTipos(Contexto, claseElemento, negocio, filtros); throw new Exception($"Debe implementar la función de CargaDeElementos para la clase '{claseElemento}' en el controlador '{GetType().Name}'"); }
public static AuditoriaDto LeerElemento(ContextoSe contexto, enumNegocio negocio, int id) { var a = new AuditoriaDeElementos(contexto, negocio); var registro = a.LeerRegistroPorId(id); var elemento = MapearRegistro(contexto, registro); return(elemento); }
public enumModoDeAccesoDeDatos LeerModoDeAccesoAlElemento(int idUsuario, enumNegocio negocio, int id) { var m = LeerModoDeAccesoAlNegocio(idUsuario, negocio); //analizar modo de acceso al elemento (por ahora sólo negocio) return(m); }
public AuditoriaDeElementos(ContextoSe contexto, enumNegocio negocio) { Dtm = negocio.TipoDtm(); Dto = negocio.TipoDto(); tablaDeAuditoria = $"{GeneradorMd.NombreDeTabla(Dtm)}_AUDITORIA"; esquemaDeAuditoria = GeneradorMd.EsquemaDeTabla(Dtm); Contexto = contexto; }
protected override dynamic CargarLista(string claseElemento, enumNegocio negocio, List <ClausulaDeFiltrado> filtro) { if (claseElemento == nameof(MenuDto)) { return(((GestorDeMenus)GestorDeElementos).LeerPadres()); } return(base.CargarLista(claseElemento, negocio, filtro)); }
private bool NegocioActivo(enumNegocio negocio) { var gestorDeNegocio = Gestores <TContexto, NegocioDtm, NegocioDto> .Obtener(Contexto, Mapeador, $"Negocio.GestorDeNegocios"); var negocioActivo = gestorDeNegocio.GetType().GetMethod("NegocioActivo"); var estaActivo = (bool)negocioActivo.Invoke(gestorDeNegocio, new object[] { negocio }); return(estaActivo); }
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 string ToNombre(this enumNegocio negocio) { if (negocio == enumNegocio.No_Definido) { return(enumNegocio.No_Definido.ToString()); } var negocioDtm = LeerNegocioPorEnumerado(negocio); return(negocioDtm.Nombre); }
public static bool EsDeParametrizacion(enumNegocio negocio) { if (negocio == enumNegocio.No_Definido) { return(false); } var negocioDto = LeerNegocioPorEnumerado(negocio); return(negocioDto.EsDeParametrizacion); }
public static bool UsaSeguridad(enumNegocio negocio) { if (negocio == enumNegocio.No_Definido) { return(false); } var negocioDto = LeerNegocioPorEnumerado(negocio); return(negocioDto.UsaSeguridad); }
internal static Type TipoDto(this enumNegocio negocio) { var negocioDto = LeerNegocioPorEnumerado(negocio); if (negocioDto.ElementoDto.IsNullOrEmpty()) { throw new Exception($"El negocio {negocio} no tiene definido el tipo Dto"); } var tipoDto = ExtensionesDto.ObtenerTypoDto(negocioDto.ElementoDto); return(tipoDto); }
public static IEnumerable <AuditoriaDto> LeerElementos(ContextoSe contexto, enumNegocio negocio, int idElemento, List <int> usuarios, int posicion, int cantidad) { var a = new AuditoriaDeElementos(contexto, negocio); var registros = a.LeerRegistros(idElemento, usuarios, posicion, cantidad); var elementos = new List <AuditoriaDto>(); foreach (var registro in registros) { var elemento = MapearRegistro(contexto, registro); elementos.Add(elemento); } return(elementos); }
public static void RegistrarAuditoria(ContextoSe contexto, enumNegocio negocio, enumTipoOperacion operacion, IElementoDtm auditar) { auditar.UsuarioModificador = auditar.UsuarioCreador = null; var valor = serializarPropiedadesPOCO(auditar); var sentencia = $@"Insert into {GeneradorMd.EsquemaDeTabla(negocio.TipoDtm())}.{GeneradorMd.NombreDeTabla(negocio.TipoDtm())}_AUDITORIA (id_elemento, id_usuario, operacion, registro, auditado_el) values ({((ElementoDtm)auditar).Id} ,{contexto.DatosDeConexion.IdUsuario} ,'{operacion.ToBd()}' ,'{valor}' ,'{DateTime.Now}')"; contexto.Database.ExecuteSqlRaw(sentencia); }
private static NegocioDtm CrearNegocio(GestorDeNegocios gestor, enumNegocio negocio, string nombre, Type dtm, Type dto, string icono) { var negocioDtm = new NegocioDtm(); negocioDtm.Enumerado = negocio.ToString(); negocioDtm.Nombre = nombre; negocioDtm.ElementoDtm = dtm.FullName; negocioDtm.ElementoDto = dto.FullName; negocioDtm.Icono = icono; negocioDtm.Activo = true; var p = new ParametrosDeNegocio(enumTipoOperacion.Insertar); return(gestor.PersistirRegistro(negocioDtm, p)); }
private static NegocioDtm CrearNegocioSiNoExiste(GestorDeNegocios gestor, enumNegocio negocio, string nombre, Type dtm, Type dto, string icono) { var negocioDtm = gestor.LeerNegocioParaModificar(negocio, errorSiNoHay: false); if (negocioDtm == null) { negocioDtm = CrearNegocio(gestor, negocio, nombre, dtm, dto, icono); } else { negocioDtm = ActualizarNegocio(gestor, negocioDtm, dtm, dto); } return(negocioDtm); }
public static string UrlParaMostrarUnNegocio(enumNegocio negocio) { var negocioDto = LeerNegocioPorEnumerado(negocio); var elementoDto = negocioDto.ElementoDto; if (elementoDto.IsNullOrEmpty()) { GestorDeErrores.Emitir($"No se ha definido el elementoDto para el negocio {negocioDto.Nombre}"); } var tipoDto = ExtensionesDto.ObtenerTypoDto(elementoDto); return(ExtensionesDto.UrlParaMostrarUnDto(tipoDto)); }
protected override dynamic CargarLista(string claseElemento, enumNegocio negocio, List <ClausulaDeFiltrado> filtros) { if (claseElemento == nameof(ClasePermisoDto)) { return(((GestorDePermisos)GestorDeElementos).LeerClases()); } if (claseElemento == nameof(TipoPermisoDto)) { return(((GestorDePermisos)GestorDeElementos).LeerTipos()); } return(base.CargarLista(claseElemento, negocio, filtros)); }
public bool ValidarPermisosDePersistencia(enumTipoOperacion operacion, enumNegocio negocio, TRegistro registro) { if (Contexto.DatosDeConexion.EsAdministrador || negocio == enumNegocio.No_Definido || !NegociosDeSe.UsaSeguridad(negocio)) { return(true); } if (!Contexto.DatosDeConexion.EsAdministrador && NegociosDeSe.EsDeParametrizacion(negocio)) { GestorDeErrores.Emitir($"El usuario {Contexto.DatosDeConexion.Login} no tiene permisos de parametrización sobre el negocio {negocio.ToNombre()}"); } var modoAcceso = LeerModoDeAccesoAlNegocio(Contexto.DatosDeConexion.IdUsuario, negocio); var hayPermisos = modoAcceso == enumModoDeAccesoDeDatos.Administrador; if (!hayPermisos) { if (operacion == enumTipoOperacion.Insertar) { hayPermisos = modoAcceso == enumModoDeAccesoDeDatos.Gestor; } else { var modoAccesoElemento = LeerModoDeAccesoAlElemento(Contexto.DatosDeConexion.IdUsuario, negocio, registro.Id); hayPermisos = modoAccesoElemento == enumModoDeAccesoDeDatos.Gestor || modoAccesoElemento == enumModoDeAccesoDeDatos.Administrador; } } //var gestorDeNegocio = Gestores<TContexto, NegocioDtm, NegocioDto>.Obtener(Contexto, Mapeador, "Negocio.GestorDeNegocio"); //var negocioDtm = gestorDeNegocio.LeerRegistroCacheado(nameof(NegocioDtm.Nombre), NegociosDeSe.ToString(negocio)); //var cache = ServicioDeCaches.Obtener($"{nameof(GestorDeElementos)}.{nameof(ValidarPermisosDePersistencia)}"); //var indice = $"Usuario:{idUsuario} Permiso:{negocioDtm.IdPermisoDeGestor}"; //if (!cache.ContainsKey(indice)) //{ // var gestorDePermisosDeUnUsuario = Gestores<TContexto, PermisosDeUnUsuarioDtm, PermisosDeUnUsuarioDto>.Obtener(Contexto, Mapeador, "Entorno.GestorDePermisosDeUnUsuario"); // var filtros = new List<ClausulaDeFiltrado>(); // filtros.Add(new ClausulaDeFiltrado { Clausula = nameof(PermisosDeUnUsuarioDtm.IdUsuario), Criterio = CriteriosDeFiltrado.igual, Valor = idUsuario.ToString() }); // filtros.Add(new ClausulaDeFiltrado { Clausula = nameof(PermisosDeUnUsuarioDtm.IdPermiso), Criterio = CriteriosDeFiltrado.esAlgunoDe, Valor = $"{negocioDtm.IdPermisoDeGestor},{negocioDtm.IdPermisoDeAdministrador}" }); // if (gestorDePermisosDeUnUsuario.Contar(filtros) == 0) // GestorDeErrores.Emitir($"El usuario {Contexto.DatosDeConexion.Login} no tiene permisos para {operacion.ToString().ToLower()} los datos de {NegociosDeSe.ToString(negocio)}"); // cache[indice] = true; //} //return (bool)cache[indice]; return(hayPermisos); }
public bool NegocioActivo(enumNegocio negocio) { if (negocio == enumNegocio.No_Definido) { return(true); } if (!NegociosDeSe.UsaSeguridad(negocio)) { return(true); } var registro = LeerRegistroCacheado(nameof(NegocioDtm.Nombre), negocio.ToNombre(), false, true, false); if (registro == null) { GestorDeErrores.Emitir($"El negocio de {NegociosDeSe.ToNombre(negocio)} no está definido, y se ha indicado por programa que usa seguridad, defínalo como negocio"); } return(registro.Activo); }
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]); }
private List <ModoDeAccesoAlNegocioDtm> ModosDeAccesoAlNegocio(int idUsuario, enumNegocio negocio) { var nombreNegocio = negocio.ToNombre(); var modosDeAcceso = Contexto .ModoAccesoAlNegocio .FromSqlInterpolated($@" SELECT ID , ADMINISTRADOR , GESTOR , CONSULTOR , IDUSUA , IDPERMISO , ORIGEN FROM NEGOCIO.MODO_ACCESO_AL_NEGOCIO_POR_USUARIO({nombreNegocio},{idUsuario}) " ).ToList(); return(modosDeAcceso); }
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]); }
protected virtual enumModoDeAccesoDeDatos LeerModoAccesoAlNegocio(int idUsuario, enumNegocio negocio) { return(GestorDeNegocios.LeerModoDeAcceso(Contexto, negocio)); }
public static enumModoDeAccesoDeDatos LeerModoDeAccesoAlElemento(ContextoSe contexto, enumNegocio negocio, int id) { var gestor = Gestor(contexto, contexto.Mapeador); return(gestor.LeerModoDeAccesoAlElemento(contexto.DatosDeConexion.IdUsuario, negocio, id)); }
public static NegocioDtm LeerNegocio(ContextoSe contexto, enumNegocio negocio) { var gestor = Gestor(contexto, contexto.Mapeador); return(gestor.LeerNegocio(negocio)); }
public NegocioDtm LeerNegocioParaModificar(enumNegocio negocio, bool errorSiNoHay = true) { var negocioDtm = LeerRegistro(nameof(NegocioDtm.Enumerado), negocio.ToString(), errorSiNoHay, true, true, false, aplicarJoin: false); return(negocioDtm); }
public static bool EsUnNegocio(this enumNegocio negocio) { return(negocio != enumNegocio.No_Definido); }