public static IQueryable <TRegistro> AplicarFiltroPorBooleano <TRegistro>(this IQueryable <TRegistro> registros, ClausulaDeFiltrado filtro, string propiedad)
{
string expresion;
if (filtro.Valor == null)
{
return(registros);
}
var valorBooleano = bool.Parse(filtro.Valor);
switch (filtro.Criterio)
{
case CriteriosDeFiltrado.igual:
expresion = $"x => x.{propiedad} == {valorBooleano}";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.diferente:
expresion = $"x => x.{propiedad} != {valorBooleano}";
return(registros.AplicarFiltroPorExpresion(expresion));
default:
GestorDeErrores.Emitir($"El filtro {filtro.Clausula} para la entidad {registros.GetType()} por el criterio {filtro.Criterio} no está definido");
break;
}
return(registros);
}
public TRegistro LeerRegistro(List <ClausulaDeFiltrado> filtros, ParametrosDeNegocio parametros, bool errorSiNoHay, bool errorSiHayMasDeUno)
{
List <TRegistro> registros = LeerRegistros(0, -1, filtros, null, null, parametros);
if (errorSiNoHay && registros.Count == 0)
{
GestorDeErrores.Emitir($"No se ha localizado el registro solicitada para los filtros indicados en la clase {typeof(TRegistro).Name}");
}
if (errorSiHayMasDeUno && registros.Count > 1)
{
GestorDeErrores.Emitir($"Hay más de un registro para los filtros indicados en la clase {typeof(TRegistro).Name}");
}
if (registros.Count == 0)
{
return(null);
}
if (registros.Count > 1)
{
return(registros[0]);
}
return(registros[0]);
}
public JsonResult epLeerModoDeAccesoAlElemento(string negocio, int id)
{
var r = new Resultado();
try
{
var modoDeAcceso = enumModoDeAccesoDeDatos.SinPermiso;
ApiController.CumplimentarDatosDeUsuarioDeConexion(GestorDeElementos.Contexto, GestorDeElementos.Mapeador, HttpContext);
var opcionesDeMapeo = new Dictionary <string, object>();
opcionesDeMapeo.Add(ltrParametrosDto.DescargarGestionDocumental, false);
var elemento = GestorDeElementos.LeerElementoPorId(id, opcionesDeMapeo);
modoDeAcceso = GestorDeElementos.LeerModoDeAccesoAlElemento(DatosDeConexion.IdUsuario, NegociosDeSe.ToEnumerado(negocio), id);
if (modoDeAcceso == enumModoDeAccesoDeDatos.SinPermiso)
{
GestorDeErrores.Emitir("El usuario conectado no tiene acceso al elemento solicitado");
}
r.Datos = elemento;
r.ModoDeAcceso = modoDeAcceso.Render();
r.consola = $"El usuario {DatosDeConexion.Login} tiene permisos de {modoDeAcceso} sobre el elemento seleccionado";
r.Estado = enumEstadoPeticion.Ok;
}
catch (Exception e)
{
ApiController.PrepararError(e, r, $"Error al obtener los permisos sobre el elemento {id} del {negocio} para el usuario {DatosDeConexion.Login}.");
}
return(new JsonResult(r));
}
public static MunicipioDtm LeerMunicipioPorCodigo(ContextoSe contexto, string iso2Pais, string codigoProvincia, string codigoMunicipio, bool paraActualizar, bool errorSiNoHay = true, bool errorSiMasDeUno = true)
{
var gestor = Gestor(contexto, contexto.Mapeador);
var filtros = new List <ClausulaDeFiltrado>();
var filtro1 = new ClausulaDeFiltrado(nameof(iso2Pais), CriteriosDeFiltrado.igual, iso2Pais);
var filtro2 = new ClausulaDeFiltrado(nameof(codigoProvincia), CriteriosDeFiltrado.igual, codigoProvincia);
var filtro3 = new ClausulaDeFiltrado(nameof(codigoMunicipio), CriteriosDeFiltrado.igual, codigoMunicipio);
filtros.Add(filtro1);
filtros.Add(filtro2);
filtros.Add(filtro3);
var p = new ParametrosDeNegocio(paraActualizar ? enumTipoOperacion.LeerConBloqueo : enumTipoOperacion.LeerSinBloqueo);
p.Parametros.Add(ltrJoinAudt.IncluirUsuarioDtm, false);
List <MunicipioDtm> municipios = gestor.LeerRegistros(0, -1, filtros, null, null, p);
if (municipios.Count == 0 && errorSiNoHay)
{
GestorDeErrores.Emitir($"No se ha localizado el municipio con Iso2 del pais {iso2Pais}, codigo de provincia {codigoProvincia} y código municipio {codigoMunicipio}");
}
if (municipios.Count > 1 && errorSiMasDeUno)
{
GestorDeErrores.Emitir($"Se han localizado más de un registro con Iso2 del pais {iso2Pais}, codigo de provincia {codigoProvincia} y código municipio {codigoMunicipio}");
}
return(municipios.Count == 1 ? municipios[0] : null);
}
protected override void AntesDePersistirValidarRegistro(NegocioDtm registro, ParametrosDeNegocio parametros)
{
base.AntesDePersistirValidarRegistro(registro, parametros);
if (registro.ElementoDtm.IsNullOrEmpty())
{
GestorDeErrores.Emitir($"Ha de indicar la clase del objeto {registro.Nombre} es obligatorio");
}
var encontrado = false;
var ensamblado = Assembly.Load(nameof(ServicioDeDatos));
foreach (var clase in ensamblado.DefinedTypes)
{
if (clase.FullName == registro.ElementoDtm)
{
encontrado = true;
break;
}
}
if (!encontrado)
{
GestorDeErrores.Emitir($"La clase del elemento {registro.ElementoDtm} del negocio {registro.Nombre} debe existir");
}
}
protected virtual void AntesMapearRegistroParaModificar(TElemento elemento, ParametrosDeNegocio opciones)
{
if (elemento.Id == 0)
{
GestorDeErrores.Emitir($"No puede modificar un elemento {typeof(TElemento).Name} con id 0");
}
}
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]);
}
private static string LeerValorDeVariable(string variable, bool emitirError = true)
{
var consulta = new ConsultaSql <VariableDtm>(VariableSqls.LeerValorDeVariable);
var valores = new Dictionary <string, object> {
{ $"@{nameof(variable)}", variable }
};
var resultado = consulta.LanzarConsulta(new DynamicParameters(valores));
if (resultado.Count == 0)
{
if (emitirError)
{
GestorDeErrores.Emitir($"No se localiza la variable {variable}");
}
else
{
return(Literal.VariableNoDefinida);
}
}
if (resultado.Count > 1)
{
GestorDeErrores.Emitir($"Hay más de un registros para la {variable}");
}
return(resultado[0].Valor);
}
public static object ValorDelAtributo(Type clase, string nombreAtributo, bool obligatorio = true)
{
Attribute[] atributosDelGestor = Attribute.GetCustomAttributes(clase);
if (atributosDelGestor == null || atributosDelGestor.Length == 0)
{
GestorDeErrores.Emitir($"No hay definido atributos {nameof(NegocioAttribute)} para el gestor {clase.Name}");
}
foreach (Attribute propiedad in atributosDelGestor)
{
if (propiedad is NegocioAttribute)
{
NegocioAttribute a = (NegocioAttribute)propiedad;
switch (nombreAtributo)
{
case nameof(NegocioAttribute.Negocio):
return(a.Negocio);
}
if (obligatorio)
{
throw new Exception($"Se ha solicitado el atributo {nameof(NegocioAttribute)}.{nombreAtributo} de la clase {clase.Name} y no está definido");
}
}
}
return(null);
}
protected virtual void AntesMapearRegistroParaInsertar(TElemento elemento, ParametrosDeNegocio opciones)
{
if (elemento.Id > 0)
{
GestorDeErrores.Emitir($"No puede crear un elemento {typeof(TElemento).Name} con id {elemento.Id}");
}
}
public TRegistro LeerRegistro(string propiedad, string valor, bool errorSiNoHay, bool errorSiHayMasDeUno, bool traqueado, bool conBloqueo, bool aplicarJoin)
{
List <TRegistro> registros = LeerRegistroInterno(propiedad, valor, traqueado, conBloqueo, aplicarJoin);
if (errorSiNoHay && registros.Count == 0)
{
GestorDeErrores.Emitir($"No se ha localizado el registro solicitada para el valor {valor} en la clase {typeof(TRegistro).Name}");
}
if (errorSiHayMasDeUno && registros.Count > 1)
{
GestorDeErrores.Emitir($"Hay más de un registro para el valor {valor} en la clase {typeof(TRegistro).Name}");
}
if (registros.Count == 0)
{
return(null);
}
if (registros.Count > 1)
{
return(registros[0]);
}
return(registros[0]);
}
internal static TipoDtoElmento ValidarElementoDto(TipoDtoElmento elemento)
{
if (elemento.IdElemento <= 0)
{
GestorDeErrores.Emitir("El elemento dto a validar no tiene indicado el Id");
}
if (elemento.TipoDto.IsNullOrEmpty())
{
GestorDeErrores.Emitir("El TipoDto a validar no puede ser nulo");
}
if (elemento.Referencia.IsNullOrEmpty())
{
GestorDeErrores.Emitir("La referencia del elemnto ser nula");
}
try
{
elemento.ClaseDto();
}
catch (Exception e)
{
GestorDeErrores.Emitir($"Error al obtener la clase del TipoDto {elemento.TipoDto}", e);
}
return(elemento);
}
protected virtual void AntesDePersistirValidarRegistro(TRegistro registro, ParametrosDeNegocio parametros)
{
var negocio = NegociosDeSe.NegocioDeUnDtm(registro.GetType().FullName);
if (!Contexto.DatosDeConexion.CreandoModelo && (!parametros.Parametros.ContainsKey(NegociosDeSe.ValidarSeguridad) || (bool)parametros.Parametros[NegociosDeSe.ValidarSeguridad]))
{
ValidarPermisosDePersistencia(parametros.Operacion, negocio, registro);
}
if ((parametros.Operacion == enumTipoOperacion.Insertar || parametros.Operacion == enumTipoOperacion.Modificar) && registro.ImplementaNombre())
{
var propiedades = registro.PropiedadesDelObjeto();
foreach (var propiedad in propiedades)
{
if (propiedad.Name == nameof(INombre.Nombre))
{
if (((string)propiedad.GetValue(registro)).IsNullOrEmpty())
{
GestorDeErrores.Emitir($"El nombre del objeto {typeof(TRegistro).Name} es obligatorio");
}
break;
}
}
}
if (parametros.Operacion == enumTipoOperacion.Modificar || parametros.Operacion == enumTipoOperacion.Eliminar)
{
}
}
internal static ProvinciaDtm LeerProvinciaPorCodigo(ContextoSe contexto, string iso2Pais, string codigoProvincia, bool paraActualizar, bool errorSiNoHay = true, bool errorSiMasDeUno = true)
{
var gestor = Gestor(contexto, contexto.Mapeador);
var filtros = new List <ClausulaDeFiltrado>();
var filtro1 = new ClausulaDeFiltrado(nameof(ProvinciaDtm.Pais.ISO2), CriteriosDeFiltrado.igual, iso2Pais);
var filtro2 = new ClausulaDeFiltrado(nameof(ProvinciaDtm.Codigo), CriteriosDeFiltrado.igual, codigoProvincia);
filtros.Add(filtro1);
filtros.Add(filtro2);
var p = new ParametrosDeNegocio(paraActualizar ? enumTipoOperacion.LeerConBloqueo : enumTipoOperacion.LeerSinBloqueo);
p.Parametros.Add(ltrJoinAudt.IncluirUsuarioDtm, false);
List <ProvinciaDtm> provincias = gestor.LeerRegistros(0, -1, filtros, null, null, p);
if (provincias.Count == 0 && errorSiNoHay)
{
GestorDeErrores.Emitir($"No se ha localizado la provincia para el código del pais {iso2Pais} y codigo de provincia {codigoProvincia}");
}
if (provincias.Count > 1 && errorSiMasDeUno)
{
GestorDeErrores.Emitir($"Se han localizado más de un registro de provincia con el código del pais {iso2Pais} y codigo de provincia {codigoProvincia}");
}
return(provincias.Count == 1 ? provincias[0] : null);
}
public (TRelacion relacio, bool existe) CrearRelacion(string propiedadIdElemento1, int idElemento1, int idElemento2, bool errorSiYaExiste)
{
var registro = ApiDeRegistro.RegistroVacio <TRelacion>();
if (!registro.ImplementaUnaRelacion())
{
throw new Exception($"El registro {typeof(TRelacion)} no es de relación.");
}
var filtros = new List <ClausulaDeFiltrado>();
DefinirFiltroDeRelacion(registro, filtros, propiedadIdElemento1, idElemento1, idElemento2);
var registros = ValidarAntesDeRelacionar(filtros).ToList();
if (registros.Count != 0 && errorSiYaExiste)
{
GestorDeErrores.Emitir($"El registro {registro} ya existe");
}
if (registros.Count == 0)
{
MapearDatosDeRelacion(registro, propiedadIdElemento1, idElemento1, idElemento2);
return(PersistirRegistro(registro, new ParametrosDeNegocio(enumTipoOperacion.Insertar)), false);
}
return(registros[0], true);
}
//Todo: --> Reglas de negocio
protected override void AntesDePersistir(ProvinciaDtm registro, ParametrosDeNegocio parametros)
{
base.AntesDePersistir(registro, parametros);
if (parametros.Operacion == enumTipoOperacion.Modificar)
{
//validar que si la provincia está relacionada con códigos postales, los dos primeros dígitos del código son igual que el código de la provincia
var a = Contexto.Set <CpsDeUnaProvinciaDtm>().FirstOrDefault(x => x.IdProvincia == registro.Id && x.CodigoPostal.Codigo.Substring(0, 2) != registro.Codigo);
if (a != null)
{
var codigoPostal = Contexto.Set <CodigoPostalDtm>().LeerCacheadoPorId(a.IdCp).Codigo;
GestorDeErrores.Emitir($"No se puede modificar la provincia ya que el código de la provincia es {registro.Codigo} y está relacionada con el código postal {codigoPostal}");
}
}
if (parametros.Operacion == enumTipoOperacion.Eliminar)
{
//Validar que no hay municipios con la provincia
var municipio = Contexto.Set <MunicipioDtm>().FirstOrDefault(x => x.IdProvincia == registro.Id);
if (municipio != null)
{
GestorDeErrores.Emitir($"No se puede eliminar la provincia por estar relacionada con el municipio {municipio.Expresion}");
}
//Elimina las relaciones del los cp con la provincia a borrar
var a = Contexto.Set <CpsDeUnaProvinciaDtm>().Where(x => x.IdProvincia == registro.Id);
GestorDeCpsDeUnaProvincia.Gestor(Contexto, Contexto.Mapeador).BorrarRegistros(a);
}
}
public static void ValidarJson(string json)
{
JSchemaGenerator generator = new JSchemaGenerator();
JSchema schema = generator.Generate(typeof(List <Parametro>));
try
{
JArray actualJson = JArray.Parse(json);
bool valid = actualJson.IsValid(schema, out IList <string> errorMessages);
if (!valid)
{
var mensaje = "";
foreach (var me in errorMessages)
{
mensaje = $"{mensaje}{Environment.NewLine}{me}";
}
GestorDeErrores.Emitir($"Parámetros Json mal definido.{Environment.NewLine}{json}{Environment.NewLine}{mensaje}");
}
}
catch (Exception exc)
{
GestorDeErrores.Emitir($"Json mal definido", exc);
}
}
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]);
}
private void ValidarAntesDeModificar(TrabajoDeUsuarioDtm registro, ParametrosDeNegocio parametros)
{
var RegistroEnBD = ((TrabajoDeUsuarioDtm)parametros.registroEnBd);
if (RegistroEnBD.IdSometedor != registro.IdSometedor)
{
GestorDeErrores.Emitir("No se puede modificar el sometedor de un trabajo");
}
if (RegistroEnBD.Encolado != registro.Encolado)
{
GestorDeErrores.Emitir("No se puede modificar la fecha de entrada de un trabajo en la cola");
}
if (!registro.Iniciado.HasValue && registro.Terminado.HasValue)
{
GestorDeErrores.Emitir("No se se puede terminar un trabajo que aun no se ha iniciado");
}
if (registro.Terminado.HasValue && !SeEstaTerminando(parametros.Parametros))
{
GestorDeErrores.Emitir("No se se puede modificar un trabajo terminado");
}
if (RegistroEnBD.Iniciado.HasValue && !SeEstaTerminando(parametros.Parametros))
{
GestorDeErrores.Emitir("Un trabajo en ejecución no se puede modificar");
}
}
public static void ValidarExistePa(string nombrePa, string esquema)
{
var pas = Leer(nombrePa, esquema);
if (pas.Count == 0)
{
GestorDeErrores.Emitir($"El {esquema}.{nombrePa} indicado no existe en la BD");
}
}
private void ValidarAntesDeEliminar(TrabajoDeUsuarioDtm registro, ParametrosDeNegocio parametros)
{
var RegistroEnBD = ((TrabajoDeUsuarioDtm)parametros.registroEnBd);
if (RegistroEnBD.Iniciado.HasValue && !RegistroEnBD.Terminado.HasValue)
{
GestorDeErrores.Emitir("Un trabajo en ejecución no se puede eliminar");
}
}
public static void ImportarFicheroDeCodigosPostales(EntornoDeTrabajo entorno, int idArchivo)
{
var gestor = Gestor(entorno.contextoDelProceso, entorno.contextoDelProceso.Mapeador);
var rutaFichero = GestorDocumental.DescargarArchivo(entorno.contextoDelProceso, idArchivo, entorno.ProcesoIniciadoPorLaCola);
var fichero = new FicheroCsv(rutaFichero);
var linea = 0;
entorno.CrearTraza($"Inicio del proceso");
var trazaPrcDtm = entorno.CrearTraza($"Procesando la fila {linea}");
var trazaInfDtm = entorno.CrearTraza($"Traza informativa del proceso");
foreach (var fila in fichero)
{
var tran = gestor.IniciarTransaccion();
try
{
linea++;
if (fila.EnBlanco)
{
continue;
}
if (fila.Columnas != 3)
{
throw new Exception($"la fila {linea} solo debe tener 3 columnas");
}
if (fila["A"].IsNullOrEmpty())
{
GestorDeErrores.Emitir($"El contenido de la fila {linea} donde se indica la provincia, celda A, no puede ser nulo");
}
if (fila["B"].IsNullOrEmpty())
{
GestorDeErrores.Emitir($"El contenido de la fila {linea} donde se indica el municipio, celda B, no puede ser nulo");
}
if (fila["C"].IsNullOrEmpty())
{
GestorDeErrores.Emitir($"El contenido de la fila {linea} donde se indica el CP, celda C, no puede ser nulo");
}
ProcesarCodigosPostales(entorno, gestor, fila["A"], fila["B"], fila["C"], trazaInfDtm);
gestor.Commit(tran);
}
catch (Exception e)
{
gestor.Rollback(tran);
entorno.AnotarError($"Error al procesar la línea {linea}", e);
}
finally
{
entorno.ActualizarTraza(trazaPrcDtm, $"Procesando la fila {linea}");
}
}
entorno.CrearTraza($"Procesadas un total de {linea} filas");
}
public static IQueryable <TRegistro> AplicarFiltroPorEntero <TRegistro>(this IQueryable <TRegistro> registros, ClausulaDeFiltrado filtro, string propiedad)
{
string expresion;
if (!(filtro.Criterio == CriteriosDeFiltrado.esNulo || filtro.Criterio == CriteriosDeFiltrado.noEsNulo || filtro.Criterio == CriteriosDeFiltrado.esAlgunoDe) && !filtro.Valor.EsEntero())
{
GestorDeErrores.Emitir($"Se ha solicitado filtrar por un número, y el valor pasado no lo es. Filtro: {filtro.Clausula}, Criterio {filtro.Criterio} Valor: '{filtro.Valor}' Dtm: {typeof(TRegistro).Name}. ");
}
var valorEntero = filtro.Valor.Entero();
switch (filtro.Criterio)
{
case CriteriosDeFiltrado.igual:
expresion = $"x => x.{propiedad}.Equals({valorEntero})";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.mayor:
expresion = $"x => x.{propiedad} > {valorEntero}";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.menor:
expresion = $"x => x.{propiedad} < {valorEntero}";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.mayorIgual:
expresion = $"x => x.{ propiedad} >= {valorEntero}";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.menorIgual:
expresion = $"x => x.{propiedad} <= {valorEntero}";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.esNulo:
expresion = $"x => x.{propiedad} == null";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.noEsNulo:
expresion = $"x => x.{propiedad} != null";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.diferente:
expresion = $"x => x.{propiedad} <> {valorEntero}";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.esAlgunoDe:
var lista = filtro.Valor.Split(',').Select(s => s.Entero()).ToArray();
return(registros = registros.Where($"@0.Contains({propiedad})", lista));
default:
GestorDeErrores.Emitir($"El filtro {filtro.Clausula} para la entidad {registros.GetType()} por el criterio {filtro.Criterio} no está definido");
break;
}
return(registros);
}
//
private static string RenderDescriptorControlDto(DescriptorDeTabla tabla, DescriptorDeControlDeLaTabla descriptorControl, double ancho)
{
var atributos = descriptorControl.atributos;
var htmdDescriptorControl = "";
switch (atributos.TipoDeControl)
{
case enumTipoControl.Editor:
htmdDescriptorControl = RenderEditor(tabla, descriptorControl);
break;
case enumTipoControl.RestrictorDeEdicion:
htmdDescriptorControl = RenderRestrictor(tabla, descriptorControl, ancho);
break;
case enumTipoControl.ListaDeElemento:
htmdDescriptorControl = RenderListaDeElemento(tabla, descriptorControl, ancho);
break;
case enumTipoControl.ListaDinamica:
htmdDescriptorControl = RenderListaDinamica(tabla, descriptorControl, ancho);
break;
case enumTipoControl.Archivo:
htmdDescriptorControl = RenderSelectorImagen(tabla, descriptorControl, ancho);
break;
case enumTipoControl.UrlDeArchivo:
htmdDescriptorControl = RenderSelectorImagen(tabla, descriptorControl, ancho);
break;
case enumTipoControl.Check:
htmdDescriptorControl = RenderCheck(tabla, descriptorControl);
break;
case enumTipoControl.SelectorDeFecha:
htmdDescriptorControl = RenderSelectorDeFecha(tabla, descriptorControl);
break;
case enumTipoControl.SelectorDeFechaHora:
htmdDescriptorControl = RenderSelectorDeFechaHora(tabla, descriptorControl);
break;
case enumTipoControl.AreaDeTexto:
htmdDescriptorControl = RenderAreaDeTexto(tabla, descriptorControl);
break;
default:
GestorDeErrores.Emitir($"No se ha implementado como renderizar una propiedad del tipo {atributos.TipoDeControl}");
break;
}
return(htmdDescriptorControl);
}
public static IQueryable <TRegistro> AplicarFiltroPorIdentificador <TRegistro>(this IQueryable <TRegistro> registros, ClausulaDeFiltrado filtro, string propiedad)
{
var valorEntero = filtro.Valor.Entero();
if (valorEntero == 0 && !(filtro.Criterio == CriteriosDeFiltrado.esNulo || filtro.Criterio == CriteriosDeFiltrado.noEsNulo || filtro.Criterio == CriteriosDeFiltrado.esAlgunoDe))
{
GestorDeErrores.Emitir($"Se ha solicitado filtrar por {filtro.Clausula}, con el criterio {filtro.Criterio} y el valor proporcionado es '{filtro.Valor}', y eso no se puede hacer sobre la tabla {typeof(TRegistro).Name}. ");
}
return(registros.AplicarFiltroPorEntero(filtro, propiedad));
}
public void CalcularAnchosColumnas()
{
var totalPorcentaje = 0;
var colDefinidas = 0;
var colSinDefinir = 0;
foreach (var col in Columnas)
{
if (!col.Visible)
{
continue;
}
if (col.PorAnchoMnt == 0)
{
colSinDefinir++;
}
else
{
totalPorcentaje += col.PorAnchoMnt;
colDefinidas++;
}
}
if (totalPorcentaje > 100)
{
GestorDeErrores.Emitir($"Las columnas definidas para el tipo {typeof(TElemento)} sobrepasan el 100%");
}
var porcDeReparto = 100 - totalPorcentaje;
if (colSinDefinir == 0)
{
return;
}
var porcPorColNoDefinida = porcDeReparto / colSinDefinir;
foreach (var col in Columnas)
{
if (col.PorAnchoMnt > 0 || !col.Visible)
{
continue;
}
col.PorAnchoMnt = porcPorColNoDefinida;
porcDeReparto = porcDeReparto - porcPorColNoDefinida;
if (porcPorColNoDefinida > porcDeReparto)
{
porcPorColNoDefinida = porcDeReparto;
}
}
}
protected override void AntesDePersistirValidarRegistro(CpsDeUnaProvinciaDtm registro, ParametrosDeNegocio parametros)
{
base.AntesDePersistirValidarRegistro(registro, parametros);
var provincia = Contexto.Set <ProvinciaDtm>().LeerCacheadoPorId(registro.IdProvincia);
var codigoPostal = Contexto.Set <CodigoPostalDtm>().LeerCacheadoPorId(registro.IdCp);
if (!codigoPostal.Codigo.Substring(0, 2).Equals(provincia.Codigo))
{
GestorDeErrores.Emitir($"El código postal {registro.CodigoPostal.Codigo} no se puede relacionar con la provincia {registro.Provincia.Expresion}");
}
}
public static IQueryable <TRegistro> AplicarFiltroDeCadena <TRegistro>(this IQueryable <TRegistro> registros, ClausulaDeFiltrado filtro, string propiedad)
{
string expresion;
if (filtro.Valor.IsNullOrEmpty() && !(filtro.Criterio == CriteriosDeFiltrado.esNulo || filtro.Criterio == CriteriosDeFiltrado.noEsNulo))
{
return(registros);
}
filtro = CambiarFiltro(filtro);
switch (filtro.Criterio)
{
case CriteriosDeFiltrado.igual:
expresion = $"x => x.{propiedad}.Equals(\"{filtro.Valor}\")";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.contiene:
expresion = $"x => x.{propiedad}.Contains(\"{filtro.Valor}\")";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.noContiene:
expresion = $"x => !x.{propiedad}.Contains(\"{filtro.Valor}\")";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.diferente:
expresion = $"x => !x.{propiedad}.Equals(\"{filtro.Valor}\")";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.comienza:
expresion = $"x => x.{propiedad}.StartsWith(\"{filtro.Valor}\")";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.termina:
expresion = $"x => x.{propiedad}.EndsWith(\"{filtro.Valor}\")";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.esNulo:
expresion = $"x => x.{propiedad}.IsNullOrEmpty()";
return(registros.AplicarFiltroPorExpresion(expresion));
case CriteriosDeFiltrado.noEsNulo:
expresion = $"!x => x.{propiedad}.IsNullOrEmpty()";
return(registros.AplicarFiltroPorExpresion(expresion));
default:
GestorDeErrores.Emitir($"El filtro {filtro.Clausula} para la entidad {registros.GetType()} por el criterio {filtro.Criterio} no está definido");
break;
}
return(registros);
}
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));
}
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);
}