public DescriptorDePuestoDeTrabajo(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, nameof(PuestoDeTrabajoController), nameof(PuestoDeTrabajoController.CrudPuestoDeTrabajo), modo, "Seguridad")
{
AnadirOpciondeRelacion(Mnt
, controlador: nameof(UsuariosDeUnPuestoController)
, vista: nameof(UsuariosDeUnPuestoController.CrudUsuariosDeUnPuesto)
, relacionarCon: nameof(UsuarioDto)
, navegarAlCrud: DescriptorDeMantenimiento <UsuariosDeUnPuestoDto> .NombreMnt
, nombreOpcion: "Usuarios"
, propiedadQueRestringe: nameof(PuestoDto.Id)
, propiedadRestrictora: nameof(UsuariosDeUnPuestoDto.IdPuesto)
, "Incluir usuarios en el puesto seleccionado");
AnadirOpciondeRelacion(Mnt
, controlador: nameof(RolesDeUnPuestoController)
, vista: nameof(RolesDeUnPuestoController.CrudRolesDeUnPuesto)
, relacionarCon: nameof(RolDto)
, navegarAlCrud: DescriptorDeMantenimiento <RolesDeUnPuestoDto> .NombreMnt
, nombreOpcion: "Roles"
, propiedadQueRestringe: nameof(PuestoDto.Id)
, propiedadRestrictora: nameof(RolesDeUnPuestoDto.IdPuesto)
, "Añadir roles al puesto seleccionado");
var modalDePermisos = new ModalDeConsultaDeRelaciones <PuestoDto, PermisosDeUnPuestoDto>(mantenimiento: Mnt
, tituloModal: "Permisos de un Puesto"
, crudModal: new DescriptorDePermisosDeUnPuesto(contexto, ModoDescriptor.Consulta)
, propiedadRestrictora: nameof(PermisosDeUnPuestoDto.IdPuesto));
var mostrarPermisos = new ConsultarRelaciones(modalDePermisos.IdHtml, () => modalDePermisos.RenderControl(), "Mostrar los permisos de un puesto de trabajo");
var opcion = new OpcionDeMenu <PuestoDto>(Mnt.ZonaMenu.Menu, mostrarPermisos, $"Permisos", enumModoDeAccesoDeDatos.Consultor);
Mnt.ZonaMenu.Menu.Add(opcion);
}
public DescriptorDeCpsDeUnMunicipio(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, nameof(CpsDeUnMunicipioController), nameof(CpsDeUnMunicipioController.CrudCpsDeUnMunicipio), modo, rutaBase: "Callejero")
{
var fltGeneral = Mnt.Filtro.ObtenerBloquePorEtiqueta(ltrBloques.General);
new RestrictorDeFiltro <CpsDeUnMunicipioDto>(bloque: fltGeneral
, etiqueta: "Municipio"
, propiedad: nameof(CpsDeUnMunicipioDto.IdMunicipio)
, ayuda: "buscar por municipio"
, new Posicion {
fila = 0, columna = 0
});
BuscarControlEnFiltro(ltrFiltros.Nombre).CambiarAtributos("Código postal", nameof(CpsDeUnMunicipioDto.CodigoPostal), "Buscar por 'código postal'");
var modalDePuestos = new ModalDeRelacionarElementos <CpsDeUnMunicipioDto, CodigoPostalDto>(mantenimiento: Mnt
, tituloModal: "Seleccione los códigos postales a relacionar"
, crudModal: new DescriptorDeCodigosPostales(contexto, ModoDescriptor.Relacion)
, propiedadRestrictora: nameof(CpsDeUnMunicipioDto.IdMunicipio));
var relacionarCps = new RelacionarElementos(modalDePuestos.IdHtml, () => modalDePuestos.RenderControl(), "Añadir códigos postales a la municipio");
var opcion = new OpcionDeMenu <CpsDeUnMunicipioDto>(Mnt.ZonaMenu.Menu, relacionarCps, $"C.P.", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcion);
Mnt.OrdenacionInicial = $"{nameof(CpsDeUnMunicipioDto.CodigoPostal)}:CodigoPostal.Codigo:{enumModoOrdenacion.ascendente.Render()}";
}
public DescriptorDeProvincias(ContextoSe contexto, ModoDescriptor modo)
: base(contexto
, nameof(ProvinciasController)
, nameof(ProvinciasController.CrudProvincias)
, modo
, rutaBase: "Callejero")
{
new ListasDinamicas <ProvinciaDto>(Mnt.BloqueGeneral,
etiqueta: "País",
filtrarPor: nameof(ProvinciaDto.IdPais),
ayuda: "seleccione al país",
seleccionarDe: nameof(PaisDto),
buscarPor: nameof(PaisDto.Nombre),
mostrarExpresion: $"([{nameof(PaisDto.Codigo)}]) [{nameof(PaisDto.Nombre)}]",
criterioDeBusqueda: ModeloDeDto.CriteriosDeFiltrado.contiene,
posicion: new Posicion(0, 0),
controlador: nameof(PaisesController),
restringirPor: "",
alSeleccionarBlanquearControl: "");
new EditorFiltro <ProvinciaDto>(bloque: Mnt.BloqueGeneral
, etiqueta: "Codigo"
, propiedad: nameof(ProvinciaDto.Codigo)
, ayuda: "buscar por codigo"
, new Posicion {
fila = 0, columna = 1
});
AnadirOpcionDeDependencias(Mnt
, controlador: nameof(MunicipiosController)
, vista: nameof(MunicipiosController.CrudMunicipios)
, datosDependientes: nameof(MunicipioDto)
, navegarAlCrud: DescriptorDeMantenimiento <MunicipioDto> .NombreMnt
, nombreOpcion: "Municipios"
, propiedadQueRestringe: nameof(ProvinciaDto.Id)
, propiedadRestrictora: nameof(MunicipioDto.IdProvincia)
, "Municipios de una provincia");
new EditorFiltro <ProvinciaDto>(bloque: Mnt.BloqueGeneral
, etiqueta: "CP"
, propiedad: nameof(CpsDeUnMunicipioDto.CodigoPostal)
, ayuda: "buscar por codigo postal"
, new Posicion {
fila = 1, columna = 1
});
AnadirOpciondeRelacion(Mnt
, controlador: nameof(CpsDeUnaProvinciaController)
, vista: nameof(CpsDeUnaProvinciaController.CrudCpsDeUnaProvincia)
, relacionarCon: nameof(CodigoPostalDto)
, navegarAlCrud: DescriptorDeMantenimiento <CpsDeUnaProvinciaDto> .NombreMnt
, nombreOpcion: "C.P."
, propiedadQueRestringe: nameof(ProvinciaDto.Id)
, propiedadRestrictora: nameof(CpsDeUnaProvinciaDto.IdProvincia)
, "Añadir puestos al usuario seleccionado");
RecolocarControl(Mnt.Filtro.FiltroDeNombre, new Posicion(1, 0), "Provincia", "Buscar Buscar por nombre de provincia");
Mnt.OrdenacionInicial = @$ "{nameof(ProvinciaDto.Pais)}:pais.nombre:{enumModoOrdenacion.ascendente.Render()};
{nameof(ProvinciaDto.Nombre)}:nombre:{enumModoOrdenacion.ascendente.Render()}";
public DescriptorDeRolesDeUnPermiso(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, nameof(RolesDeUnPermisoController), nameof(RolesDeUnPermisoController.CrudRolesDeUnPermiso), modo, "Seguridad")
{
var fltGeneral = Mnt.Filtro.ObtenerBloquePorEtiqueta(ltrBloques.General);
new RestrictorDeFiltro <RolesDeUnPermisoDto>(bloque: fltGeneral
, etiqueta: "Permiso"
, propiedad: nameof(RolesDeUnPermisoDto.IdPermiso)
, ayuda: "buscar por permiso"
, new Posicion {
fila = 0, columna = 0
});
BuscarControlEnFiltro(ltrFiltros.Nombre).CambiarAtributos("Rol", nameof(RolesDeUnPermisoDto.Rol), "Buscar por 'rol'");
var modalDeRoles = new ModalDeRelacionarElementos <RolesDeUnPermisoDto, RolDto>(mantenimiento: Mnt
, tituloModal: "Seleccione los roles a relacionar"
, crudModal: new DescriptorDeRol(contexto, ModoDescriptor.Relacion)
, propiedadRestrictora: nameof(RolesDeUnPermisoDto.IdPermiso));
var relacionarRoles = new RelacionarElementos(modalDeRoles.IdHtml, () => modalDeRoles.RenderControl(), "Seleccionar los roles donde incluir el permiso");
var opcion = new OpcionDeMenu <RolesDeUnPermisoDto>(Mnt.ZonaMenu.Menu, relacionarRoles, $"Roles", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcion);
AnadirOpciondeRelacion(Mnt
, controlador: nameof(PuestosDeUnRolController)
, vista: nameof(PuestosDeUnRolController.CrudPuestosDeUnRol)
, relacionarCon: nameof(PuestoDto)
, navegarAlCrud: DescriptorDeMantenimiento <PuestosDeUnRolDto> .NombreMnt
, nombreOpcion: "Puestos"
, propiedadQueRestringe: nameof(PuestosDeUnRolDto.IdRol)
, propiedadRestrictora: nameof(PuestosDeUnRolDto.IdRol)
, ayuda: "Incluir el rol a los puestos seleccionados");
}
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);
}
public DescriptorDePais(ContextoSe contexto, ModoDescriptor modo)
: base(contexto
, nameof(PaisesController)
, nameof(PaisesController.CrudPaises)
, modo
, rutaBase: "Callejero")
{
new EditorFiltro <PaisDto>(bloque: Mnt.BloqueGeneral
, etiqueta: "Codigo"
, propiedad: nameof(PaisDto.Codigo)
, ayuda: "buscar por codigo"
, new Posicion {
fila = 1, columna = 0
});
AnadirOpcionDeDependencias(Mnt
, controlador: nameof(ProvinciasController)
, vista: nameof(ProvinciasController.CrudProvincias)
, datosDependientes: nameof(ProvinciaDto)
, navegarAlCrud: DescriptorDeMantenimiento <ProvinciaDto> .NombreMnt
, nombreOpcion: "Provincias"
, propiedadQueRestringe: nameof(PaisDto.Id)
, propiedadRestrictora: nameof(ProvinciaDto.IdPais)
, "Provincias de un pais");
}
public DescriptorDeMenu(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(MenusController)
, vista: nameof(MenusController.CrudMenu)
, modo: modo
, rutaBase: "Entorno")
{
var fltEspecificos = new BloqueDeFitro <MenuDto>(filtro: Mnt.Filtro, titulo: "Específico", dimension: new Dimension(1, 2));
new ListasDinamicas <MenuDto>(bloque: fltEspecificos,
etiqueta: "Menu padre",
filtrarPor: nameof(MenuDto.idPadre),
ayuda: "seleccionar padre",
seleccionarDe: nameof(MenuDto),
buscarPor: nameof(MenuDto.Nombre),
mostrarExpresion: $"[{nameof(MenuDto.Padre)}].[{nameof(MenuDto.Nombre)}]",
criterioDeBusqueda: ModeloDeDto.CriteriosDeFiltrado.contiene,
posicion: new Posicion()
{
fila = 0, columna = 0
},
controlador: nameof(MenusController),
restringirPor: "");
new CheckFiltro <MenuDto>(bloque: fltEspecificos,
etiqueta: "Mostrar las activas",
filtrarPor: nameof(MenuDto.Activo),
ayuda: "Sólo las activos",
valorInicial: false,
filtrarPorFalse: false,
posicion: new Posicion(0, 1));
}
public DescriptorDeUsuariosDeUnPuesto(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, nameof(UsuariosDeUnPuestoController), nameof(UsuariosDeUnPuestoController.CrudUsuariosDeUnPuesto), modo, "Seguridad")
{
var fltGeneral = Mnt.Filtro.ObtenerBloquePorEtiqueta(ltrBloques.General);
new RestrictorDeFiltro <UsuariosDeUnPuestoDto>(bloque: fltGeneral
, etiqueta: "Puesto"
, propiedad: nameof(UsuariosDeUnPuestoDto.IdPuesto)
, ayuda: "buscar por puesto"
, new Posicion {
fila = 0, columna = 0
});
BuscarControlEnFiltro(ltrFiltros.Nombre).CambiarAtributos("Usuario", nameof(UsuariosDeUnPuestoDto.Usuario), "Buscar por 'usuario'");
var modalDePuestos = new ModalDeRelacionarElementos <UsuariosDeUnPuestoDto, UsuarioDto>(mantenimiento: Mnt
, tituloModal: "Seleccione los usuarios a relacionar"
, crudModal: new DescriptorDeUsuario(contexto, ModoDescriptor.Relacion)
, propiedadRestrictora: nameof(UsuariosDeUnPuestoDto.IdPuesto));
var relacionarPuestos = new RelacionarElementos(modalDePuestos.IdHtml, () => modalDePuestos.RenderControl(), "Añadir usuarios al puesto");
var opcion = new OpcionDeMenu <UsuariosDeUnPuestoDto>(Mnt.ZonaMenu.Menu, relacionarPuestos, $"Usuarios", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcion);
}
//protected DescriptorDeCrud<TElemento> Descriptor { get; set; }
public BaseController(GestorDeErrores gestorDeErrores, ContextoSe contexto, IMapper mapeador)
{
GestorDeErrores = gestorDeErrores;
Contexto = contexto;
Contexto.Mapeador = mapeador;
Contexto.IniciarTraza(GetType().Name);
}
public DescriptorDePermisosDeUnRol(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, nameof(PermisosDeUnRolController), nameof(PermisosDeUnRolController.CrudPermisosDeUnRol), modo, "Seguridad")
{
var fltGeneral = Mnt.Filtro.ObtenerBloquePorEtiqueta(ltrBloques.General);
new RestrictorDeFiltro <PermisosDeUnRolDto>(bloque: fltGeneral
, etiqueta: "Rol"
, propiedad: nameof(PermisosDeUnRolDto.IdRol)
, ayuda: "buscar por rol"
, new Posicion {
fila = 0, columna = 0
});
BuscarControlEnFiltro(ltrFiltros.Nombre).CambiarAtributos("Permiso", nameof(PermisosDeUnRolDto.Permiso), "Buscar por 'permiso'");
//Añade una opcion de menú, para relacionar permisos
//- Abre una modal de selección
//- Le pasa el id del elemento con el que se va a relacionar (para no mostrar los ya relacionados)
//- Al aceptar --> llama al negocio y relaciona los id's
//- Al cerrar no hace nada
var modalDePermisos = new ModalDeRelacionarElementos <PermisosDeUnRolDto, PermisoDto>(mantenimiento: Mnt
, tituloModal: "Seleccione los permisos a relacionar"
, crudModal: new DescriptorDePermiso(Contexto, ModoDescriptor.Relacion)
, propiedadRestrictora: nameof(PermisosDeUnRolDto.IdRol));
var relacionarPermisos = new RelacionarElementos(modalDePermisos.IdHtml, () => modalDePermisos.RenderControl(), "Seleccionar permisos a relacionar con el rol");
var opcion = new OpcionDeMenu <PermisosDeUnRolDto>(Mnt.ZonaMenu.Menu, relacionarPermisos, $"Permisos", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcion);
}
public DescriptorDeTrabajosSometido(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(TrabajosSometidoController)
, vista: $"{nameof(TrabajosSometidoController.CrudDeTrabajosSometido)}"
, modo: modo
, rutaBase: "TrabajosSometido")
{
}
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 AuditoriaDeElementos(ContextoSe contexto, enumNegocio negocio)
{
Dtm = negocio.TipoDtm();
Dto = negocio.TipoDto();
tablaDeAuditoria = $"{GeneradorMd.NombreDeTabla(Dtm)}_AUDITORIA";
esquemaDeAuditoria = GeneradorMd.EsquemaDeTabla(Dtm);
Contexto = contexto;
}
public DescriptorDePermiso(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(PermisosController), vista: nameof(PermisosController.CrudPermiso), modo: modo, "Seguridad")
{
if (modo == ModoDescriptor.Mantenimiento)
{
var modalUsuario = new DescriptorDeUsuario(contexto, ModoDescriptor.SeleccionarParaFiltrar);
var fltGeneral = Mnt.Filtro.ObtenerBloquePorEtiqueta(ltrBloques.General);
var fltEspecificos = new BloqueDeFitro <PermisoDto>(filtro: Mnt.Filtro, titulo: "Específico", dimension: new Dimension(1, 2));
new SelectorDeFiltro <PermisoDto, UsuarioDto>(padre: fltGeneral,
etiqueta: "Usuario",
filtrarPor: UsuariosPor.AlgunUsuario,
ayuda: "Seleccionar usuario",
posicion: new Posicion()
{
fila = 0, columna = 1
},
paraFiltrar: nameof(UsuarioDto.Id),
paraMostrar: nameof(UsuarioDto.NombreCompleto),
crudModal: modalUsuario,
propiedadDondeMapear: UsuariosPor.NombreCompleto.ToString());
new ListaDeElemento <PermisoDto>(padre: fltEspecificos,
etiqueta: "Clase de permiso",
ayuda: "selecciona una clase",
seleccionarDe: nameof(ClasePermisoDto),
filtraPor: nameof(PermisoDto.IdClase),
mostrarExpresion: ClasePermisoDto.MostrarExpresion,
posicion: new Posicion()
{
fila = 0, columna = 0
});
new ListaDeElemento <PermisoDto>(padre: fltEspecificos,
etiqueta: "Tipo de permiso",
ayuda: "selecciona un tipo",
seleccionarDe: nameof(TipoPermisoDto),
filtraPor: nameof(PermisoDto.IdTipo),
mostrarExpresion: nameof(TipoPermisoDto.Nombre),
posicion: new Posicion()
{
fila = 1, columna = 0
});
AnadirOpciondeRelacion(Mnt
, controlador: nameof(RolesDeUnPermisoController)
, vista: nameof(RolesDeUnPermisoController.CrudRolesDeUnPermiso)
, relacionarCon: nameof(RolDto)
, navegarAlCrud: DescriptorDeMantenimiento <RolesDeUnPermisoDto> .NombreMnt
, nombreOpcion: "Roles"
, propiedadQueRestringe: nameof(PermisoDto.Id)
, propiedadRestrictora: nameof(PermisosDeUnRolDto.IdPermiso)
, "Añadir roles al permiso seleccionado");
}
}
public static void CumplimentarDatosDeUsuarioDeConexion(ContextoSe contexto, IMapper mapeador, HttpContext httpContext)
{
contexto.DatosDeConexion.Login = ApiController.ObtenerUsuarioDeLaRequest(httpContext);
var gestorDeUsuario = GestorDeUsuarios.Gestor(contexto, mapeador);
var usuario = gestorDeUsuario.LeerRegistroCacheado(nameof(UsuarioDtm.Login), contexto.DatosDeConexion.Login, errorSiNoHay: true, errorSiHayMasDeUno: true, aplicarJoin: false);
contexto.DatosDeConexion.IdUsuario = usuario.Id;
contexto.DatosDeConexion.EsAdministrador = usuario.EsAdministrador;
contexto.Mapeador = mapeador;
}
public static void SometerBorrarTrazas(ContextoSe contexto)
{
var dll = Assembly.GetExecutingAssembly().GetName().Name;
var clase = typeof(TrabajosDeEntorno).FullName;
var ts = GestorDeTrabajosSometido.Obtener(contexto, "Borrar trazas", dll, clase, nameof(SometerBorrarTrazas).Replace("Someter", ""));
GestorDeTrabajosDeUsuario.CrearSiNoEstaPendiente(contexto, ts, new Dictionary <string, object> {
{ nameof(TrabajoDeUsuarioDtm.Planificado), DateTime.Now.AddDays(1) }
});
}
public DescriptorDeParametrosDeNegocio(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(ParametrosDeNegocioController)
, vista: $"{nameof(ParametrosDeNegocioController.CrudDeParametrosDeNegocio)}"
, modo: modo
, rutaBase: "Negocio")
{
var fltGeneral = Mnt.Filtro.ObtenerBloquePorEtiqueta(ltrBloques.General);
new RestrictorDeFiltro <ParametroDeNegocioDto>(fltGeneral, "Negocio", nameof(ParametroDeNegocioDto.IdNegocio), "parámetros del negocio", new Posicion(0, 0));
}
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);
}
private static AuditoriaDto MapearRegistro(ContextoSe contexto, AuditoriaDtm registro)
{
var elemento = new AuditoriaDto();
elemento.Id = registro.Id;
elemento.IdElemento = registro.IdElemento;
elemento.IdUsuario = registro.IdUsuario;
elemento.AuditadoEl = registro.AuditadoEl;
elemento.Operacion = registro.Operacion;
elemento.registroJson = registro.registroJson;
elemento.Usuario = UsuarioDtm.NombreCompleto(Entorno.GestorDeUsuarios.LeerUsuario(contexto, elemento.IdUsuario));
return(elemento);
}
public DescriptorDeVariable(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, nameof(VariablesController), nameof(VariablesController.CrudVariable), modo, "Entorno")
{
var fltGeneral = Mnt.Filtro.ObtenerBloquePorEtiqueta(ltrBloques.General);
new EditorFiltro <VariableDto>(bloque: fltGeneral
, etiqueta: "Valor"
, propiedad: nameof(VariableDto.Valor)
, ayuda: "buscar por valor"
, new Posicion {
fila = 0, columna = 1
});
}
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);
}
public DescriptorTiposDeVia(ContextoSe contexto, ModoDescriptor modo)
: base(contexto
, nameof(TiposDeViaController)
, nameof(TiposDeViaController.CrudTiposDeVia)
, modo
, rutaBase: "Callejero")
{
new EditorFiltro <TipoDeViaDto>(bloque: Mnt.BloqueGeneral
, etiqueta: "Sigla"
, propiedad: nameof(TipoDeViaDto.Sigla)
, ayuda: "buscar por sigla"
, new Posicion {
fila = 0, columna = 0
});
RecolocarControl(Mnt.Filtro.FiltroDeNombre, new Posicion(0, 1), "T.Vía", "buscar por tipo de vía");
}
public DescriptorDePermisosDeUnUsuario(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, nameof(PermisosDeUnUsuarioController), nameof(PermisosDeUnUsuarioController.CrudPermisosDeUnUsuario), modo, "Entorno")
{
var fltGeneral = Mnt.Filtro.ObtenerBloquePorEtiqueta(ltrBloques.General);
new RestrictorDeFiltro <PermisosDeUnUsuarioDto>(bloque: fltGeneral
, etiqueta: "Usuario"
, propiedad: nameof(PermisosDeUnUsuarioDto.IdUsuario)
, ayuda: "buscar por usuario"
, new Posicion {
fila = 0, columna = 0
});
BuscarControlEnFiltro(ltrFiltros.Nombre).CambiarAtributos("Permiso", nameof(PermisosDeUnUsuarioDto.Permiso), "Buscar por 'permiso'");
}
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 DescriptorDeNegocio(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(NegocioController)
, vista: $"{nameof(NegocioController.CrudDeNegocios)}"
, modo: modo
, rutaBase: "Negocio")
{
AnadirOpcionDeDependencias(Mnt
, controlador: nameof(ParametrosDeNegocioController)
, vista: nameof(ParametrosDeNegocioController.CrudDeParametrosDeNegocio)
, datosDependientes: nameof(ParametroDeNegocioDto)
, navegarAlCrud: DescriptorDeMantenimiento <ParametroDeNegocioDto> .NombreMnt
, nombreOpcion: "Parámetros"
, propiedadQueRestringe: nameof(NegocioDto.Id)
, propiedadRestrictora: nameof(ParametroDeNegocioDto.IdNegocio)
, "Parametros de un negocio");
}
public DescriptorDeTrazasDeUnTrabajo(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(TrazasDeUnTrabajoController)
, vista: $"{nameof(TrazasDeUnTrabajoController.CrudDeTrazasDeUnTrabajo)}"
, modo: modo
, rutaBase: "TrabajosSometido")
{
var fltGeneral = Mnt.Filtro.ObtenerBloquePorEtiqueta(ltrBloques.General);
new RestrictorDeFiltro <TrazaDeUnTrabajoDto>(bloque: fltGeneral
, etiqueta: "Trabajo de Usuario"
, propiedad: nameof(ErrorDeUnTrabajoDto.IdTrabajoDeUsuario)
, ayuda: "buscar por trabajo de usuario"
, new Posicion {
fila = 0, columna = 0
});
}
public DescriptorDeCrud(ContextoSe contexto, string controlador, string vista, ModoDescriptor modo, string rutaBase, string id = null)
: base(
padre: null,
id: id == null ? $"{NombreCrud}" : id,
etiqueta: typeof(TElemento).Name.Replace("Dto", ""),
propiedad: null,
ayuda: null,
posicion: null
)
{
var elemento = typeof(TElemento).Name.Replace("Dto", "");
RutaBase = rutaBase;
Tipo = enumTipoControl.DescriptorDeCrud;
Mnt = new DescriptorDeMantenimiento <TElemento>(crud: this, etiqueta: elemento);
Controlador = controlador.Replace("Controller", "");
Vista = $@"{vista}";
Contexto = contexto;
Modo = modo;
DefinirColumnasDelGrid();
Creador = new DescriptorDeCreacion <TElemento>(crud: this, etiqueta: elemento);
Editor = new DescriptorDeEdicion <TElemento>(crud: this, etiqueta: elemento);
Exportador = new DescriptorDeExportacion <TElemento>(crud: this);
if (modo == ModoDescriptor.Mantenimiento)
{
Mnt.ZonaMenu.AnadirOpcionDeIrACrear();
Mnt.ZonaMenu.AnadirOpcionDeIrAEditar();
Mnt.ZonaMenu.AnadirOpcionDeIrAExportar();
if (GestorDeCorreos.PermiteElEnvioDeCorreo <TElemento>())
{
Cartero = new DescriptorDeEnviarCorreo <TElemento>(crud: this);
Mnt.ZonaMenu.AnadirOpcionDeEnviareMail();
}
Borrado = new DescriptorDeBorrado <TElemento>(crud: this, etiqueta: elemento);
Mnt.ZonaMenu.AnadirOpcionDeBorrar();
DefinirDescriptorDeAuditoria();
}
}
public DescriptorDeVistaMvc(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, nameof(VistaMvcController), nameof(VistaMvcController.CrudVistaMvc), modo, "Entorno")
{
var fltGeneral = Mnt.Filtro.ObtenerBloquePorEtiqueta(ltrBloques.General);
new EditorFiltro <VistaMvcDto>(bloque: fltGeneral
, etiqueta: "Controlador"
, propiedad: nameof(VistaMvcDto.Controlador)
, ayuda: "buscar por controlador"
, new Posicion {
fila = 1, columna = 0
});
new CheckFiltro <VistaMvcDto>(bloque: fltGeneral,
etiqueta: "Mostrar solo las modales",
filtrarPor: nameof(VistaMvcDto.MostrarEnModal),
ayuda: "Sólo las las modales",
valorInicial: false,
filtrarPorFalse: false,
posicion: new Posicion(1, 1));
}
public DescriptorDeRol(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, nameof(RolController), nameof(RolController.CrudRol), modo, "Seguridad")
{
AnadirOpciondeRelacion(Mnt
, controlador: nameof(PuestosDeUnRolController)
, vista: nameof(PuestosDeUnRolController.CrudPuestosDeUnRol)
, relacionarCon: nameof(PuestoDto)
, navegarAlCrud: DescriptorDeMantenimiento <PuestosDeUnRolDto> .NombreMnt
, nombreOpcion: "Puestos"
, propiedadQueRestringe: nameof(RolDto.Id)
, propiedadRestrictora: nameof(PuestosDeUnRolDto.IdRol)
, "Incluir el rol a los puestos seleccionados");
AnadirOpciondeRelacion(Mnt
, controlador: nameof(PermisosDeUnRolController)
, vista: nameof(PermisosDeUnRolController.CrudPermisosDeUnRol)
, relacionarCon: nameof(PermisoDto)
, navegarAlCrud: DescriptorDeMantenimiento <PermisosDeUnRolDto> .NombreMnt
, nombreOpcion: "Permisos"
, propiedadQueRestringe: nameof(RolDto.Id)
, propiedadRestrictora: nameof(PermisosDeUnRolDto.IdRol)
, "Añadir permisos al rol seleccionado");
var bloque = new BloqueDeFitro <RolDto>(filtro: Mnt.Filtro, titulo: "Específico", dimension: new Dimension(1, 2));
new ListasDinamicas <RolDto>(bloque: bloque,
etiqueta: "Permisos asociado",
filtrarPor: nameof(PermisosDeUnRolDto.IdPermiso),
ayuda: "roles con el permiso",
seleccionarDe: nameof(PermisoDto),
buscarPor: nameof(PermisoDto.Nombre),
mostrarExpresion: nameof(PermisoDto.Nombre),
criterioDeBusqueda: CriteriosDeFiltrado.contiene,
posicion: new Posicion(1, 0),
controlador: nameof(PermisosController),
restringirPor: "").LongitudMinimaParaBuscar = 3;
}
public DescriptorDeAuditoria(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(AuditoriaController)
, vista: $"{nameof(AuditoriaController.CrudDeAuditoria)}"
, modo: modo
, rutaBase: "Negocio")
{
new RestrictorDeFiltro <AuditoriaDto>(bloque: Mnt.BloqueGeneral
, etiqueta: "Negocio"
, propiedad: NegocioPor.idNegocio
, ayuda: "negocio del elemento"
, new Posicion {
fila = 0, columna = 0
});
new RestrictorDeFiltro <AuditoriaDto>(bloque: Mnt.BloqueGeneral
, etiqueta: "Elemento"
, propiedad: nameof(AuditoriaDto.IdElemento)
, ayuda: "elemento auditado"
, new Posicion {
fila = 0, columna = 1
});
var modalUsuario = new DescriptorDeUsuario(Contexto, ModoDescriptor.SeleccionarParaFiltrar);
new SelectorDeFiltro <AuditoriaDto, UsuarioDto>(padre: Mnt.BloqueGeneral,
etiqueta: "Usuario",
filtrarPor: UsuariosPor.AlgunUsuario,
ayuda: "Seleccionar usuario",
posicion: new Posicion()
{
fila = 1, columna = 0
},
paraFiltrar: nameof(UsuarioDto.Id),
paraMostrar: nameof(UsuarioDto.NombreCompleto),
crudModal: modalUsuario,
propiedadDondeMapear: UsuariosPor.NombreCompleto.ToString());
}
