DeclaracionEstados ConsultarReprogramado(TablasRango tr, Personas persona)
{
var pe = ConsultarProgramadoPrimeraEntrega(tr, persona);
var se = ConsultarProgramadoSegundaEntrega(tr, persona);
return(se.Id_Tipo_Estado == ReprogramadoId ? se : pe.Id_Tipo_Estado == ReprogramadoId ? pe : new DeclaracionEstados());
}
DeclaracionEstados ConsultarProgramado(TablasRango tablasRango, Personas persona, int tipoEntregaId)
{
return(tablasRango.DeclaracionEstados
.Where(q => q.Id_Declaracion == persona.Id_Declaracion &&
(q.Id_Tipo_Estado == ProgramadoId || q.Id_Tipo_Estado == ReprogramadoId) &&
q.Id_Como_Estado == SiId)
.Join(tablasRango.Programacion
.Where(x => x.Id_TipoEntrega == tipoEntregaId),
a => a.Id_Programa,
b => b.Id, (a, b) =>
new DeclaracionEstados
{
Id = a.Id,
Fecha = b.Fecha,
Id_Declaracion = a.Id_Declaracion,
Id_Tipo_Estado = a.Id_Tipo_Estado,
Id_Como_Estado = a.Id_Como_Estado,
Id_Programa = a.Id_Programa,
Id_Asistio = a.Id_Asistio
})
.OrderByDescending(f => f.Fecha)
.ThenByDescending(f => f.Id)
.Take(1)
.SingleOrDefault()
?? new DeclaracionEstados());
}
public void CrearRango(ITengoFechaRadicacionDesdeHasta rangoFechas, TablasRango tablasRango)
{
var rango = transformoFechas.ConvertirEnRango(rangoFechas);
var _dirrango = ObtenerDirectorioLanzarErrorSiExiste(rango);
_dirrango.Create();
CrearRangoImp(rango, tablasRango.SubTablas, sololectura: true);
CrearRangoImp(rango, tablasRango.Programacion, sololectura: true);
CrearRangoImp(rango, tablasRango.Declaracion, sololectura: true);
CrearRangoImp(rango, tablasRango.Personas, sololectura: true);
CrearRangoImp(rango, tablasRango.PersonasContactos, sololectura: true);
CrearRangoImp(rango, tablasRango.PersonasEducacion, sololectura: true);
CrearRangoImp(rango, tablasRango.PersonasRegimenSalud, sololectura: true);
CrearRangoImp(rango, tablasRango.DeclaracionBienes, sololectura: true);
CrearRangoImp(rango, tablasRango.DeclaracionCausasDesplazamiento, sololectura: true);
CrearRangoImp(rango, tablasRango.DeclaracionDaniosFamilia, sololectura: true);
CrearRangoImp(rango, tablasRango.DeclaracionEstados, sololectura: true);
CrearRangoImp(rango, tablasRango.DeclaracionFuentesIngreso, sololectura: true);
CrearRangoImp(rango, tablasRango.DeclaracionObtencionAgua, sololectura: true);
CrearRangoImp(rango, tablasRango.DeclaracionPersonasAyuda, sololectura: true);
CrearRangoImp(rango, tablasRango.DeclaracionPsicosocial, sololectura: true);
CrearMeta(rango, tablasRango, rangoFechas);
}
string ConsultarAtendido(TablasRango tr, Personas persona)
{
var declaracion = ConsultarDeclaracion(tr, persona);
var atendido = declaracion.Id_Motivo_Noatender.HasValue && declaracion.Id_Motivo_Noatender.Value != ProgramadoQueNoAsistioId ? NoId : declaracion.Id_Atender;
return(ConsultarDescripcionPorId(tr, atendido));
}
public virtual void ActualizarDestino(TablasRango tablasRango, Personas persona, TDestino destino)
{
PropiedadesConMetodo.ForEach(propiedad =>
{
destino.SetPropertyValue(propiedad, Resolver(propiedad, tablasRango, persona));
});
}
protected Personas ConsultarPersonaDeclarante(TablasRango tablasRango, Personas persona)
{
return(tablasRango.Personas.
FirstOrDefault(x => x.Id_Declaracion == persona.Id_Declaracion &&
x.Tipo == PersonaTipo.Declarante.ToString())
?? new Personas());
}
public ResponseCreate Crear(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
repositorioRango.LanzarExcepcionCuandoExisteRango(rangoFechas);
TablasRango tr = ConsultarTablasRango(rangoFechas); //repositorioRango.ConsultarTablasRango(peticion);
repositorioRango.CrearRango(rangoFechas, tr);
return(new ResponseCreate());
}
string ConsultarTipoReprogramacion(TablasRango tr, Personas persona)
{
var estado = ConsultarReprogramado(tr, persona);
var programa = tr.Programacion
.FirstOrDefault(x => x.Id == estado.Id_Programa) ?? new Programacion();
return(ConsultarDescripcionPorId(tr, programa.Id_TipoEntrega));
}
DeclaracionEstados ConsultarContactado(TablasRango tr, Personas persona)
{
(_contactado.Id_Declaracion != persona.Id_Declaracion)
.SiCumpleEntonces(() =>
{
_contactado = ConsultarDeclaracionEstado(tr, persona, ContactadoId);
});
return(_contactado);
}
DeclaracionEstados ConsultarDeclaracionEstado(TablasRango tr, Personas persona, int tipoEstadoId)
{
return(tr.DeclaracionEstados
.FindAll(q => q.Id_Declaracion == persona.Id_Declaracion && q.Id_Tipo_Estado == tipoEstadoId)
.OrderByDescending(q => q.Fecha)
.ThenByDescending(q => q.Id)
.Take(1)
.SingleOrDefault()
?? new DeclaracionEstados());
}
protected int ConsultarTFE(TablasRango tablasRango, Personas persona)
{
var declaracion = ConsultarDeclaracion(tablasRango, persona);
return((declaracion.Menores_Ninas.HasValue ? declaracion.Menores_Ninas.Value : 0) +
(declaracion.Menores_Ninos.HasValue ? declaracion.Menores_Ninos.Value : 0) +
(declaracion.Recien_Nacidos.HasValue ? declaracion.Recien_Nacidos.Value : 0) +
(declaracion.Lactantes.HasValue ? declaracion.Lactantes.Value : 0) +
(declaracion.Resto_Nucleo.HasValue ? declaracion.Resto_Nucleo.Value : 0));
}
DeclaracionEstados ConsultarProgramadoSegundaEntrega(TablasRango tr, Personas persona)
{
(_programadoSegundaEntrega.Id_Declaracion != persona.Id_Declaracion)
.SiCumpleEntonces(() =>
{
_programadoSegundaEntrega = ConsultarProgramado(tr, persona, SegundaEntregaId);
});
return(_programadoSegundaEntrega);
}
protected Declaracion ConsultarDeclaracion(TablasRango tablasRango, Personas persona)
{
(_declaracion.Id != persona.Id_Declaracion)
.SiCumpleEntonces(() => {
_declaracion = tablasRango.Declaracion
.FirstOrDefault(x => x.Id == persona.Id_Declaracion)
?? new Declaracion();
});
return(_declaracion);
}
public virtual TDestino CrearDestino(TablasRango tablasRango, Personas persona)
{
var destino = new TDestino();
PropiedadesConMetodo.ForEach(propiedad =>
{
destino.SetPropertyValue(propiedad, Resolver(propiedad, tablasRango, persona));
});
return(destino);
}
protected PersonasContactos ConsultarContacto(TablasRango tr, Personas persona,
int?idTipoContacto)
{
return(tr.PersonasContactos
.FindAll(q =>
q.Id_Persona == persona.Id && q.Id_Tipo_Contacto == idTipoContacto)
.OrderBy(q => q.Activo)
.OrderByDescending(q => q.Id)
.Take(1)
.SingleOrDefault() ?? new PersonasContactos());
}
public virtual List <TDestino> Consultar(TablasRango tablasRango)
{
var lista = new List <TDestino>();
tablasRango.Personas.ForEach(Persona =>
{
var r = CrearDestino(tablasRango, Persona);
lista.Add(r);
});
return(lista);
}
private void CrearMeta(string rango, TablasRango tablas, ITengoFechaRadicacionDesdeHasta query)
{
var regionales = tablas.Declaracion.GroupBy(r => r.Id_Regional).Select(reg => new RegionalObjetivo
{
Nombre = tablas.SubTablas.Find(st => st.Id == reg.Key).Descripcion,
Municipios = reg.GroupBy(mn => mn.Id_lugar_fuente).Select(municipio => new MunicipioObjectivo
{
Nombre = tablas.SubTablas.Find(st => st.Id == municipio.Key).Descripcion,
Regional = tablas.SubTablas.Find(st => st.Id == reg.Key).Descripcion,
AniosMesesRadicacion = municipio.GroupBy(per => per.Fecha_Radicacion.EnAnioMes()).Select(periodo => new AnioMesObjetivo
{
Nombre = periodo.Key,
Municipio = tablas.SubTablas.Find(st => st.Id == municipio.Key).Descripcion,
Regional = tablas.SubTablas.Find(st => st.Id == reg.Key).Descripcion,
}).OrderBy(x => x.Nombre).ToList(),
AniosMesesAtencion = municipio.Where(q => q.Fecha_Valoracion.HasValue)
.GroupBy(per => per.Fecha_Valoracion.EnAnioMes())
.Select(periodo => new AnioMesObjetivo
{
Nombre = periodo.Key,
Municipio = tablas.SubTablas.Find(st => st.Id == municipio.Key).Descripcion,
Regional = tablas.SubTablas.Find(st => st.Id == reg.Key).Descripcion,
}).OrderBy(x => x.Nombre).ToList()
}).ToList()
}).ToList();
var municipios = new List <string>();
regionales.ForEach(reg =>
{
municipios.AddRange(reg.Municipios.GroupBy(g => g.Nombre).Select(q => q.Key));
});
var ri = new Rango
{
Regionales = regionales,
Municipios = municipios,
Nombre = rango,
Periodo = transformoFechas.ConvertirRangoEnPeriodo(rango),
AnioMes = transformoFechas.ConvertirRangoEnAnioMes(rango),
FechaRadicacionDesde = query.FechaRadicacionDesde,
FechaRadicacionHasta = query.FechaRadicacionHasta
};
var rangos = ConsultarRango();
RemoverRangoDeLaLista(rango, rangos);
rangos.Add(ri);
GuardarRangos(rangos);
}
public TablasRango ConsultarTablasRango(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
var rango = transformoFechas.ConvertirEnRango(rangoFechas);
var tablas = new TablasRango();
tablas.Declaracion = ObtenerTablaRango <Declaracion>(rango);
tablas.DeclaracionEstados = ObtenerTablaRango <DeclaracionEstados>(rango);
tablas.Personas = ObtenerTablaRango <Personas>(rango);
tablas.PersonasContactos = ObtenerTablaRango <PersonasContactos>(rango);
tablas.PersonasEducacion = ObtenerTablaRango <PersonasEducacion>(rango);
tablas.PersonasRegimenSalud = ObtenerTablaRango <PersonasRegimenSalud>(rango);
tablas.Programacion = ObtenerTablaRango <Programacion>(rango);
tablas.SubTablas = ObtenerTablaRango <SubTablas>(rango);
return(tablas);
}
protected int?ConsultarTFR(TablasRango tablasRango, Personas persona)
{
var declaracion = ConsultarDeclaracion(tablasRango, persona);
int?conteo = null;
(declaracion.Fecha_Valoracion.HasValue)
.SiCumpleEntonces(() =>
{
conteo = ConsultarPersonasDeclaracion(tablasRango, declaracion)
.Count;
});
return(conteo);
}
DeclaracionEstados ConsultarElegibilidad(TablasRango tr, Personas persona)
{
(_elegible.Id_Declaracion != persona.Id_Declaracion)
.SiCumpleEntonces(() =>
{
_elegible = ConsultarDeclaracionEstado(tr, persona, ElegibleId);
var declaracion = ConsultarDeclaracion(tr, persona);
(declaracion.Id_Motivo_Noatender.HasValue && declaracion.Id_Motivo_Noatender != ProgramadoQueNoAsistioId)
.SiCumpleEntonces(() =>
{
_elegible.Id_Como_Estado = NoId;
});
});
return(_elegible);
}
public virtual List <TDestino> Consultar(TablasRango tablasRango, PersonaTipo personaTipo)
{
var tipo = personaTipo.ToString().First().ToString();
var lista = new List <TDestino>();
tablasRango.Personas
.Where(x => x.Tipo == tipo)
.ToList()
.ForEach(Persona =>
{
var r = CrearDestino(tablasRango, Persona);
lista.Add(r);
});
return(lista);
}
static void TestContenedores()
{
var contenedor = new ContenedorMetodos <EstadoAtencion>();
TablasRango tablasRando = new TablasRango();
Personas persona = new Personas();
contenedor.Registrar("Nombre", (tr, decl) => "Angel Colmenares");
contenedor.Registrar("Edad", (tr, decl) => 1);
var nombre = contenedor.Resolver("Nombre", tablasRando, persona);
var edad = contenedor.Resolver("Edad", tablasRando, persona);
Console.WriteLine("{0} {1}", nombre, edad);
var objNombre = contenedor.Resolver("Nombre", tablasRando, persona);
var objEdad = contenedor.Resolver("Edad", tablasRando, persona);
Console.WriteLine("{0} {1}", objNombre, objEdad);
Console.WriteLine("{0} {1}", objNombre.GetType(), objEdad.GetType());
var g = new GeneradorEstadoAtencion(new ContenedorMetodos <EstadoAtencion>());
var opnombre = g.Resolver(f => f.PrimerNombre, tablasRando, persona);
var osnombre = g.Resolver(f => f.SegundoNombre, tablasRando, persona);
var odireccion = g.Resolver(f => f.Direccion, tablasRando, persona);
Console.WriteLine("Resueltos {0} {1} {2} ", opnombre, osnombre, odireccion);
var estadoAtencion = g.CrearDestino(tablasRando, persona);
Console.WriteLine("Resueltos 0 {0} {1} {2}", estadoAtencion.PrimerNombre, estadoAtencion.SegundoNombre, estadoAtencion.Celular);
persona.Id = 1;
estadoAtencion = g.CrearDestino(tablasRando, persona);
Console.WriteLine("Resueltos 1 {0} {1} {2}", estadoAtencion.PrimerNombre, estadoAtencion.SegundoNombre, estadoAtencion.Celular);
return;
}
public TablasRango ConsultarTablasRango(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
var tr = new TablasRango();
tr.SubTablas = Consultar <SubTablas>(rangoFechas);
tr.Programacion = Consultar <Programacion>(rangoFechas);
tr.Declaracion = ConsultarPorRangoFechaRadicacion <Declaracion>(rangoFechas);
tr.DeclaracionEstados = Consultar <DeclaracionEstados>(rangoFechas, tr.Declaracion);
tr.Personas = Consultar <Personas>(rangoFechas, tr.Declaracion);
tr.PersonasContactos = Consultar <PersonasContactos>(rangoFechas, tr.Personas);
tr.PersonasEducacion = Consultar <PersonasEducacion>(rangoFechas, tr.Personas);
tr.PersonasRegimenSalud = Consultar <PersonasRegimenSalud>(rangoFechas, tr.Personas);
tr.DeclaracionBienes = Consultar <DeclaracionBienes>(rangoFechas, tr.Declaracion);
tr.DeclaracionCausasDesplazamiento = Consultar <DeclaracionCausasDesplazamiento>(rangoFechas, tr.Declaracion);
tr.DeclaracionDaniosFamilia = Consultar <DeclaracionDaniosFamilia>(rangoFechas, tr.Declaracion);
tr.DeclaracionFuentesIngreso = Consultar <DeclaracionFuentesIngreso>(rangoFechas, tr.Declaracion);
tr.DeclaracionObtencionAgua = Consultar <DeclaracionObtencionAgua>(rangoFechas, tr.Declaracion);
tr.DeclaracionPersonasAyuda = Consultar <DeclaracionPersonasAyuda>(rangoFechas, tr.Declaracion);
tr.DeclaracionPsicosocial = Consultar <DeclaracionPsicosocial>(rangoFechas, tr.Declaracion);
return(tr);
}
public object Resolver(string nombrePropiedad, TablasRango tablasRango, Personas persona)
{
object factoria = contenedor[nombrePropiedad];
return(((Func <TablasRango, Personas, object>)factoria).Invoke(tablasRango, persona));
}
public TTipo Resolver <TTipo>(Expression <Func <TDestino, TTipo> > propiedad, TablasRango tablasRango, Personas declaracion)
{
return(contenedor.Resolver <TTipo>(propiedad, tablasRango, declaracion));
}
public object Resolver(string nombrePropiedad, TablasRango tablasRango, Personas persona)
{
return(contenedor.Resolver(nombrePropiedad, tablasRango, persona));
}
string ConsultarComoEstado(TablasRango tr, DeclaracionEstados estado)
{
return(ConsultarDescripcionPorId(tr, estado.Id_Como_Estado));
}
protected string ConsultarDescripcionPorId(TablasRango tr, int?idSubtabla)
{
var r = tr.SubTablas.FirstOrDefault(q => q.Id == idSubtabla);
return((r != default(SubTablas)) ? r.Descripcion : string.Empty);
}
DateTime?ConsultarFechaAtencion(TablasRango tr, Personas persona)
{
var declaracion = ConsultarDeclaracion(tr, persona);
return(declaracion.Id_Atender.HasValue && declaracion.Id_Atender.Value == SiId ? declaracion.Fecha_Valoracion : null);
}
protected List <Personas> ConsultarPersonasDeclaracion(TablasRango tr, Declaracion declaracion)
{
return(tr.Personas
.Where(x => x.Id_Declaracion == declaracion.Id)
.ToList());
}
