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");
}
}
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]);
}
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 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 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);
}
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");
}
}
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);
}
}
//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);
}
}
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");
}
}
//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 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 (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);
}
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);
}
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);
}
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 JsonResult epBloquearTrabajoDeUsuario(int idTrabajoUsuario)
{
var r = new Resultado();
try
{
ApiController.CumplimentarDatosDeUsuarioDeConexion(GestorDeElementos.Contexto, GestorDeElementos.Mapeador, HttpContext);
GestorDeTrabajosDeUsuario.Bloquear(GestorDeElementos.Contexto, idTrabajoUsuario);
r.Estado = enumEstadoPeticion.Ok;
r.Mensaje = "Trabajo bloqueado";
}
catch (Exception e)
{
r.Estado = enumEstadoPeticion.Error;
r.consola = GestorDeErrores.Detalle(e);
if (e.Data.Contains(GestorDeErrores.Datos.Mostrar) && (bool)e.Data[GestorDeErrores.Datos.Mostrar] == true)
{
r.Mensaje = e.Message;
}
else
{
r.Mensaje = $"Error al bloquear el trabajo. {(e.Data.Contains(GestorDeErrores.Datos.Mostrar) && (bool)e.Data[GestorDeErrores.Datos.Mostrar] == true ? e.Message : "")}";
}
}
return(new JsonResult(r));
}
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 CallesController(GestorDeCalles gestorDeCalles, GestorDeErrores gestorDeErrores)
: base
(
gestorDeCalles,
gestorDeErrores
)
{
}
public TrabajosDeUsuarioController(GestorDeTrabajosDeUsuario gestorDeTu, GestorDeErrores gestorDeErrores)
: base
(
gestorDeTu,
gestorDeErrores
)
{
}
public VistaMvcController(GestorDeVistaMvc gestorDeVistas, GestorDeErrores gestorDeErrores)
: base
(
gestorDeVistas,
gestorDeErrores
)
{
}
public CorreosController(GestorDeCorreos gestorDeCorreos, GestorDeErrores gestorDeErrores)
: base
(
gestorDeCorreos,
gestorDeErrores
)
{
}
public PuestosDeUnUsuarioController(GestorDePuestosDeUnUsuario gestor, GestorDeErrores errores)
: base
(
gestor,
errores
)
{
}
public TrabajosSometidoController(GestorDeTrabajosSometido gestorDeTrabajos, GestorDeErrores gestorDeErrores)
: base
(
gestorDeTrabajos,
gestorDeErrores
)
{
}
public TiposDeViaController(GestorDeTiposDeVia gestorDeTiposDeVia, GestorDeErrores gestorDeErrores)
: base
(
gestorDeTiposDeVia,
gestorDeErrores
)
{
}
public RolController(GestorDeRoles gestor, GestorDeErrores gestorDeErrores)
: base
(
gestor,
gestorDeErrores
)
{
}
public PermisosDeUnPuestoController(GestorDePermisosDeUnPuesto gestor, GestorDeErrores errores)
: base
(
gestor,
errores
)
{
}