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 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 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 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 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 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);
}
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 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 DescriptorDeTrabajosSometido(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(TrabajosSometidoController)
, vista: $"{nameof(TrabajosSometidoController.CrudDeTrabajosSometido)}"
, modo: modo
, rutaBase: "TrabajosSometido")
{
}
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 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 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 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 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));
}
private static string RenderGestorDeEventos(ModoDescriptor modo)
{
var getorDeEventos = $"{GestorDeEventos.EventosDelMantenimiento}";
if (modo == ModoDescriptor.SeleccionarParaFiltrar)
{
getorDeEventos = $"{GestorDeEventos.EventosModalDeSeleccion}";
}
if (modo == ModoDescriptor.ParaSeleccionar)
{
getorDeEventos = $"{GestorDeEventos.EventosModalParaSeleccionar}";
}
if (modo == ModoDescriptor.Relacion)
{
getorDeEventos = $"{GestorDeEventos.EventosModalDeCrearRelaciones}";
}
if (modo == ModoDescriptor.Consulta)
{
getorDeEventos = $"{GestorDeEventos.EventosModalDeConsultaDeRelaciones}";
}
return(getorDeEventos);
}
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());
}
public DescriptorDeCodigosPostales(ContextoSe contexto, ModoDescriptor modo)
: base(contexto
, nameof(CodigosPostalesController)
, nameof(CodigosPostalesController.CrudCodigosPostales)
, modo
, rutaBase: "Callejero")
{
var opcionProvincias = AnadirOpcionDeDependencias(Mnt
, controlador: nameof(ProvinciasController)
, vista: nameof(ProvinciasController.CrudProvincias)
, datosDependientes: nameof(ProvinciaDto)
, navegarAlCrud: DescriptorDeMantenimiento <ProvinciaDto> .NombreMnt
, nombreOpcion: "Provincias"
, propiedadQueRestringe: nameof(CodigoPostalDto.Codigo)
, propiedadRestrictora: nameof(CpsDeUnaProvinciaDto.CodigoPostal)
, "Provincias de un CP");
opcionProvincias.SoloMapearEnElFiltro = true;
var opcionMunicipios = AnadirOpcionDeDependencias(Mnt
, controlador: nameof(MunicipiosController)
, vista: nameof(MunicipiosController.CrudMunicipios)
, datosDependientes: nameof(MunicipioDto)
, navegarAlCrud: DescriptorDeMantenimiento <MunicipioDto> .NombreMnt
, nombreOpcion: "Municipios"
, propiedadQueRestringe: nameof(CodigoPostalDto.Codigo)
, propiedadRestrictora: nameof(CpsDeUnMunicipioDto.CodigoPostal)
, "Municipios de un CP");
opcionMunicipios.SoloMapearEnElFiltro = true;
BuscarControlEnFiltro(ltrFiltros.Nombre).CambiarAtributos("Código Postal", nameof(CodigoPostalDto.Codigo), "Buscar por 'código postal'");
Mnt.OrdenacionInicial = @$ "{nameof(CodigoPostalDto.Codigo)}:codigo:{enumModoOrdenacion.ascendente.Render()}";
}
public void CambiarModo(ModoDescriptor modo)
{
Modo = modo;
}
public DescriptorDeUsuario(ContextoSe contexto, ModoDescriptor modo, string id)
: base(contexto,
controlador: nameof(UsuariosController)
, vista: $"{nameof(UsuariosController.CrudUsuario)}"
, modo: modo
, rutaBase: "Entorno"
, id)
{
if (modo == ModoDescriptor.Mantenimiento)
{
var bloque = new BloqueDeFitro <UsuarioDto>(filtro: Mnt.Filtro, titulo: "Específico", dimension: new Dimension(3, 2));
new SelectorDeFiltro <UsuarioDto, PermisoDto>(
padre: bloque,
etiqueta: "Permiso",
filtrarPor: UsuariosPor.Permisos,
ayuda: "Seleccionar Permiso",
posicion: new Posicion(0, 0),
paraFiltrar: nameof(PermisoDto.Id),
paraMostrar: nameof(PermisoDto.Nombre),
crudModal: new DescriptorDePermiso(Contexto, ModoDescriptor.SeleccionarParaFiltrar),
propiedadDondeMapear: ltrFiltros.Nombre.ToString());
new ListasDinamicas <UsuarioDto>(bloque: bloque,
etiqueta: "Puesto de trabajo",
filtrarPor: nameof(PuestosDeUnUsuarioDto.IdPuesto),
ayuda: "usuarios de este puesto",
seleccionarDe: nameof(PuestoDto),
buscarPor: nameof(PuestoDto.Nombre),
mostrarExpresion: nameof(PuestoDto.Nombre),
criterioDeBusqueda: CriteriosDeFiltrado.contiene,
posicion: new Posicion(1, 0),
controlador: nameof(PuestoDeTrabajoController),
restringirPor: "").LongitudMinimaParaBuscar = 1;
new ListasDinamicas <UsuarioDto>(bloque: bloque,
etiqueta: "Roles",
filtrarPor: nameof(RolesDeUnPuestoDto.IdRol),
ayuda: "usuarios de un rol",
seleccionarDe: nameof(RolDto),
buscarPor: nameof(RolDto.Nombre),
mostrarExpresion: nameof(RolDto.Nombre),
criterioDeBusqueda: CriteriosDeFiltrado.contiene,
posicion: new Posicion(2, 0),
controlador: nameof(RolController),
restringirPor: "").LongitudMinimaParaBuscar = 1;
new ListasDinamicas <UsuarioDto>(bloque: bloque,
etiqueta: "Permisos",
filtrarPor: nameof(PermisosDeUnUsuarioDto.IdPermiso),
ayuda: "permisos de un usuario",
seleccionarDe: nameof(PermisoDto),
buscarPor: nameof(PermisoDto.Nombre),
mostrarExpresion: nameof(PermisoDto.Nombre),
criterioDeBusqueda: CriteriosDeFiltrado.comienza,
posicion: new Posicion(3, 0),
controlador: nameof(PermisosController),
restringirPor: "").LongitudMinimaParaBuscar = 3;
}
BuscarControlEnFiltro(ltrFiltros.Nombre).CambiarAtributos("Usuario", UsuariosPor.NombreCompleto, "Buscar por 'apellido, nombre'");
var modalDePermisos = new ModalDeConsultaDeRelaciones <UsuarioDto, PermisosDeUnUsuarioDto>(mantenimiento: Mnt
, tituloModal: "Permisos de un usuario"
, crudModal: new DescriptorDePermisosDeUnUsuario(Contexto, ModoDescriptor.Consulta)
, propiedadRestrictora: nameof(PermisosDeUnUsuarioDto.IdUsuario));
var mostrarPermisos = new ConsultarRelaciones(modalDePermisos.IdHtml, () => modalDePermisos.RenderControl(), "Mostrar los permisos de un usuario");
var opcion = new OpcionDeMenu <UsuarioDto>(Mnt.ZonaMenu.Menu, mostrarPermisos, $"Permisos", enumModoDeAccesoDeDatos.Consultor);
Mnt.ZonaMenu.Menu.Add(opcion);
AnadirOpciondeRelacion(Mnt
, controlador: nameof(PuestosDeUnUsuarioController)
, vista: nameof(PuestosDeUnUsuarioController.CrudPuestosDeUnUsuario)
, relacionarCon: nameof(PuestoDto)
, navegarAlCrud: DescriptorDeMantenimiento <PuestosDeUnUsuarioDto> .NombreMnt
, nombreOpcion: "Puestos"
, propiedadQueRestringe: nameof(UsuarioDto.Id)
, propiedadRestrictora: nameof(PuestosDeUnUsuarioDto.IdUsuario)
, "Añadir puestos al usuario seleccionado");
Mnt.OrdenacionInicial = @$ "{nameof(UsuarioDto.NombreCompleto)}:nombre:{enumModoOrdenacion.ascendente.Render()}";
}
public DescriptorDeUsuario(ContextoSe contexto, ModoDescriptor modo) : this(contexto, modo, null)
{
}
public DescriptorDeTrabajosDeUsuario(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(TrabajosDeUsuarioController)
, vista: $"{nameof(TrabajosDeUsuarioController.CrudDeTrabajosDeUsuario)}"
, modo: modo
, rutaBase: "TrabajosSometido")
{
var opcion = new OpcionDeMenu <TrabajoDeUsuarioDto>(Mnt.ZonaMenu.Menu, AccionesDeTu.Iniciar, $"Ejecutar", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcion);
var opcionBloquear = new OpcionDeMenu <TrabajoDeUsuarioDto>(Mnt.ZonaMenu.Menu, AccionesDeTu.Bloquear, $"Bloquear", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcionBloquear);
var opcionDesbloquear = new OpcionDeMenu <TrabajoDeUsuarioDto>(Mnt.ZonaMenu.Menu, AccionesDeTu.Desbloquear, $"Desbloquear", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcionDesbloquear);
var opcionResometer = new OpcionDeMenu <TrabajoDeUsuarioDto>(Mnt.ZonaMenu.Menu, AccionesDeTu.Resometer, $"Resometer", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcionResometer);
AnadirOpcionDeDependencias(Mnt
, controlador: nameof(TrazasDeUnTrabajoController)
, vista: nameof(TrazasDeUnTrabajoController.CrudDeTrazasDeUnTrabajo)
, datosDependientes: nameof(TrazaDeUnTrabajoDto)
, navegarAlCrud: DescriptorDeMantenimiento <TrazaDeUnTrabajoDto> .NombreMnt
, nombreOpcion: "Traza"
, propiedadQueRestringe: nameof(TrabajoDeUsuarioDto.Id)
, propiedadRestrictora: nameof(TrazaDeUnTrabajoDto.IdTrabajoDeUsuario)
, "Consultar la traza del trabajo de usuario");
AnadirOpcionDeDependencias(Mnt
, controlador: nameof(ErroresDeUnTrabajoController)
, vista: nameof(ErroresDeUnTrabajoController.CrudDeErroresDeUnTrabajo)
, datosDependientes: nameof(ErrorDeUnTrabajoDto)
, navegarAlCrud: DescriptorDeMantenimiento <ErrorDeUnTrabajoDto> .NombreMnt
, nombreOpcion: "Errores"
, propiedadQueRestringe: nameof(TrabajoDeUsuarioDto.Id)
, propiedadRestrictora: nameof(ErrorDeUnTrabajoDto.IdTrabajoDeUsuario)
, "Consultar errores del trabajo de usuario");
new FiltroEntreFechas <TrabajoDeUsuarioDto>(bloque: Mnt.BloqueComun,
etiqueta: "Planificado",
propiedad: nameof(TrabajoDeUsuarioDto.Planificado),
ayuda: "trabajos planificados entre",
posicion: new Posicion()
{
fila = 0, columna = 0
});
new FiltroEntreFechas <TrabajoDeUsuarioDto>(bloque: Mnt.BloqueComun,
etiqueta: "Ejecutado entre",
propiedad: nameof(TrabajoDeUsuarioDto.Iniciado),
ayuda: "trabajos ejecutados entre",
posicion: new Posicion()
{
fila = 1, columna = 0
});
Dictionary <string, string> opciones = typeof(enumEstadosDeUnTrabajo).ToDiccionario((x) => TrabajoSometido.EnumeradoToDtm(x));
new ListaDeValores <TrabajoDeUsuarioDto>(Mnt.BloqueGeneral
, "Estado"
, "Seleccione el estado por el que filtrar"
, opciones
, nameof(TrabajoDeUsuarioDto.Estado)
, new Posicion()
{
fila = 0, columna = 1
});
Mnt.OrdenacionInicial = @$ "{nameof(TrabajoDeUsuarioDto.Planificado)}:planificado:{enumModoOrdenacion.descendente.Render()};
{nameof(TrabajoDeUsuarioDto.Iniciado)}:iniciado:{enumModoOrdenacion.ascendente.Render()}";
public DescriptorDeCorreos(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(CorreosController)
, vista: $"{nameof(CorreosController.CrudDeCorreos)}"
, modo: modo
, rutaBase: "TrabajosSometido")
{
RenombrarEtiqueta(nameof(INombre.Nombre), "Texto", "Buscar en el asunto o cuerpo del mensaje");
var UsuarioReceptor = new DescriptorDeUsuario(Contexto, ModoDescriptor.SeleccionarParaFiltrar);
new SelectorDeFiltro <CorreoDto, UsuarioDto>(padre: Mnt.BloqueGeneral,
etiqueta: "Receptor",
filtrarPor: UsuariosPor.eMail,
ayuda: "Seleccionar usuario receptor",
posicion: new Posicion()
{
fila = 0, columna = 1
},
paraFiltrar: nameof(UsuarioDto.Id),
paraMostrar: nameof(UsuarioDto.NombreCompleto),
crudModal: UsuarioReceptor,
propiedadDondeMapear: UsuariosPor.NombreCompleto.ToString());
var UsuarioCreador = new DescriptorDeUsuario(Contexto, ModoDescriptor.SeleccionarParaFiltrar);
new SelectorDeFiltro <CorreoDto, UsuarioDto>(padre: Mnt.BloqueComun,
etiqueta: "Usuario",
filtrarPor: nameof(CorreoDto.IdUsuario),
ayuda: "Usuario creador del correo",
posicion: new Posicion()
{
fila = 0, columna = 0
},
paraFiltrar: nameof(UsuarioDto.Id),
paraMostrar: nameof(UsuarioDto.NombreCompleto),
crudModal: UsuarioCreador,
propiedadDondeMapear: UsuariosPor.NombreCompleto.ToString());
new CheckFiltro <CorreoDto>(Mnt.BloqueComun,
etiqueta: "Mostrar los enviados",
filtrarPor: nameof(ltrFltCorreosDto.seHaEnviado),
ayuda: "Sólo los enviados",
valorInicial: false,
filtrarPorFalse: false,
posicion: new Posicion(0, 1));
new CheckFiltro <CorreoDto>(Mnt.BloqueComun,
etiqueta: "Mostrar los no enviados",
filtrarPor: nameof(ltrFltCorreosDto.NoSeHaEnviado),
ayuda: "Sólo los no enviados",
valorInicial: false,
filtrarPorFalse: false,
posicion: new Posicion(1, 1));
new FiltroEntreFechas <CorreoDto>(bloque: Mnt.BloqueComun,
etiqueta: "creado entre",
propiedad: nameof(CorreoDto.Creado),
ayuda: "correos creados entre las fechas indicadas",
posicion: new Posicion()
{
fila = 1, columna = 0
});
new FiltroEntreFechas <CorreoDto>(bloque: Mnt.BloqueComun,
etiqueta: "Enviado entre",
propiedad: nameof(CorreoDto.Enviado),
ayuda: "correos enviados entre las fechas indicadas",
posicion: new Posicion()
{
fila = 2, columna = 0
});
Editor.MenuDeEdicion.QuitarOpcionDeMenu(TipoDeAccionDeEdicion.ModificarElemento);
Mnt.OrdenacionInicial = @$ "{nameof(CorreoDto.Creado)}:creado:{enumModoOrdenacion.descendente.Render()};
{nameof(CorreoDto.Enviado)}:enviado:{enumModoOrdenacion.ascendente.Render()}";
public DescriptorDeClaseDePermiso(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, nameof(ClaseDePermisoController), nameof(ClaseDePermisoController.CrudClaseDePermiso), modo, "Seguridad")
{
}
