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