public ResponseCreate Crear(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
var indicador = Consultar(rangoFechas).Results;
repositorioIndicador.CrearIndicadorObjetivoNecesidadesBasicas(rangoFechas, indicador);
return(new ResponseCreate());
}
List <TDatoObjetivo> ConsultarDesdeHerramienta_O_Generar(ITengoFechaRadicacionDesdeHasta rango)
{
var lista = repositorioDatoObjetivoNecesidadesBasicas.ConsultarDatoObjetivoNecesidadesBasicas <TDatoObjetivo>(rango);
lista.SiEstaVaciaEntonces(() => lista = GenerarDesdeTablaRangos(rango));
return(lista);
}
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);
}
List <T> ConsultarImp <T>(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
var rango = transformoFechas.ConvertirEnRango(rangoFechas);
var archivoJson = NombreCompletoJson <T>(rango);
return(File.Exists(archivoJson) ? ReadListFromFile <T>(archivoJson) : new List <T>());
}
public bool ExisteRango(ITengoFechaRadicacionDesdeHasta query)
{
var rango = transformoFechas.ConvertirEnRango(query);
var _dirrango = new DirectoryInfo(Path.Combine(directorioRaiz.FullName, rango));
return(_dirrango.Exists);
}
List <T> ConsultarDeHerramienta_O_Repositorio <T>(ITengoFechaRadicacionDesdeHasta rango) where T : IEntidad
{
var lista = repositorioRango.ConsultarTablaRango <T>(rango);
lista.SiEstaVaciaEntonces(() => lista = repositorioPrincipal.Consultar <T>());
return(lista);
}
public ResponseCreate Crear(ITengoFechaRadicacionDesdeHasta peticion)
{
repositorioDatoObjetivoNecesidadesBasicas.LanzarCuandoExiste <EstadoAtencion>(peticion);
var datoObjetivoNecesidadesBasicas = Consultar(peticion).Results;
repositorioDatoObjetivoNecesidadesBasicas.CrearDatoObjetivoNecesidadesBasicas(peticion, datoObjetivoNecesidadesBasicas);
return(new ResponseCreate());
}
public ResponseCreate Crear(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
repositorioRango.LanzarExcepcionCuandoExisteRango(rangoFechas);
TablasRango tr = ConsultarTablasRango(rangoFechas); //repositorioRango.ConsultarTablasRango(peticion);
repositorioRango.CrearRango(rangoFechas, tr);
return(new ResponseCreate());
}
void LanzarCuandoNoExiste(ITengoFechaRadicacionDesdeHasta rangoFechas, Type type)
{
var rango = transformoFechas.ConvertirEnRango(rangoFechas);
if (!ExisteJson(rango, type))
{
throw new Exception(string.Format("Elemento {0} No existe en el Rango {1}", type.Name, rango));
}
}
public QueryResponse <TDatoObjetivo> Consultar(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
var lista = cacheClient.Consultar(rangoFechas,
() => ConsultarDesdeHerramienta_O_Generar(rangoFechas));
return(new QueryResponse <TDatoObjetivo> {
Results = lista, Total = lista.Count
});
}
public string ConvertirEnLlave <T>(ITengoFechaRadicacionDesdeHasta query)
{
var type = typeof(T);
var name = type.Name.StartsWith("QueryResponse`", StringComparison.Ordinal) ? "Query" + type.GetGenericArguments()[0].Name :
type.Name.StartsWith("List`", StringComparison.Ordinal) ? type.GetGenericArguments()[0].Name :
type.Name;
return("{0}{1}".Fmt(name, ConvertirEnRango(query)));
}
protected void DeleteFile <T>(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
var rango = transformoFechas.ConvertirEnRango(rangoFechas);
var archivoJson = NombreCompletoJson <T>(rango);
File.Exists(archivoJson).SiCumpleEntonces(() =>
{
File.Delete(archivoJson);
});
}
public void CrearIndicadorObjetivoNecesidadesBasicas <T>(ITengoFechaRadicacionDesdeHasta rangoFechas, List <T> indicadorObjetivo) where T : IIndicadorNecesidadBasica
{
LanzarCuandoExiste(rangoFechas, typeof(T));
var rango = transformoFechas.ConvertirEnRango(rangoFechas);
ObtenerDirectorioLanzarErrorSiNoExiste(rango);
var archivoJson = NombreCompletoJson <T>(rango);
SaveToFile(indicadorObjetivo, archivoJson);
}
public void BorrarRango(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
var rango = transformoFechas.ConvertirEnRango(rangoFechas);
var _dirrango = ObtenerDirectorioLanzarErrorSiNoExiste(rango);
_dirrango.Delete(true);
var rangos = ConsultarRango();
RemoverRangoDeLaLista(rango, rangos);
GuardarRangos(rangos);
}
public virtual QueryResponse <TIndicador> Consultar(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
var listaIndicador =
cacheClient.Consultar(rangoFechas,
() => ConsultarDatosObjetivo_Y_AplicarFitros(rangoFechas));
return(new QueryResponse <TIndicador>
{
Results = listaIndicador,
Total = listaIndicador.Count
});
}
List <T> ConsultarPorIdsPersonasDeHerramienta_O_Repositorio <T>(ITengoFechaRadicacionDesdeHasta rangoFechas,
List <Personas> personas)
where T : IEntidad, IConIdPersona
{
var lista = repositorioRango.ConsultarTablaRango <T>(rangoFechas);
lista.SiEstaVaciaEntonces(() =>
{
var idsPersonas = personas.ConvertAll(q => q.Id);
lista = repositorioPrincipal.ConsultarPorIdsPersonas <T>(idsPersonas);
});
return(lista);
}
List <T> ConsultarPorIdsDeclaracionDeHerramienta_O_Repositorio <T>(ITengoFechaRadicacionDesdeHasta rangoFechas,
List <Declaracion> declaracion)
where T : IEntidad, IConIdDeclaracion
{
var lista = repositorioRango.ConsultarTablaRango <T>(rangoFechas);
lista.SiEstaVaciaEntonces(() =>
{
var idsDeclaracion = declaracion.ConvertAll(q => q.Id);
lista = repositorioPrincipal.ConsultarPorIdsDeclaracion <T>(idsDeclaracion);
});
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);
}
public List <T> Consultar <T>(ITengoFechaRadicacionDesdeHasta rangoFechas, Func <List <T> > funcionConsultar, bool refrescar = false) where T : class
{
var key = GetKey <T>(rangoFechas);
var r = new List <T>();
(!refrescar).SiCumpleEntonces(() =>
{
r = cacheClient.Get <List <T> >(key);
});
r.SiEsNullEntonces(() =>
{
r = funcionConsultar();
cacheClient.Set(key, r, TimeSpan.FromMinutes(10));
});
return(r);
}
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 ResponseDelete Borrar(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
cacheClient.Borrar <TIndicador>(rangoFechas);
repositorioIndicador.BorrarIndicadorObjetivoNecesidadesBasicas <TIndicador>(rangoFechas);
return(new ResponseDelete());
}
public string ConvertirEnRango(ITengoFechaRadicacionDesdeHasta query)
{
return("{0}{1}".Fmt(
(query.FechaRadicacionDesde.HasValue ? query.FechaRadicacionDesde.Value : DateTime.MinValue).EnAAAAMMDD(),
(query.FechaRadicacionHasta.HasValue ? query.FechaRadicacionHasta.Value : DateTime.Now.AddDays(1)).EnAAAAMMDD()));
}
public string ConvertirEnURN <T>(ITengoFechaRadicacionDesdeHasta query)
{
return("urn:{0}".Fmt(ConvertirEnLlave <T>(query)));
}
public bool ExisteDatoObjetivoNecesidadesBasicas <T>(ITengoFechaRadicacionDesdeHasta rangoFechas) where T : INecesidadBasica
{
var rango = transformoFechas.ConvertirEnRango(rangoFechas);
return(ExisteJson <T>(rango));
}
public List <T> ConsultarTablaRango <T>(ITengoFechaRadicacionDesdeHasta rangoFechas) where T : IEntidad
{
var rango = transformoFechas.ConvertirEnRango(rangoFechas);
return(ObtenerTablaRango <T>(rango));
}
public List <T> ConsultarDatoObjetivoNecesidadesBasicas <T>(ITengoFechaRadicacionDesdeHasta rangoFechas)
where T : INecesidadBasica
{
return(ConsultarImp <T>(rangoFechas));
}
public List <Rango> ConsultarRango(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
return(ConsultarRango());
}
List <TIndicador> ConsultarDatosObjetivo_Y_AplicarFitros(ITengoFechaRadicacionDesdeHasta rangoFechas)
{
var datosObjectivo = gestorNecesidadesBasicas.Consultar(rangoFechas).Results;
return(filtro.AplicarFiltros(datosObjectivo));
}
public void BorrarIndicadorObjetivoNecesidadesBasicas <T>(ITengoFechaRadicacionDesdeHasta rangoFechas) where T : IIndicadorNecesidadBasica
{
LanzarCuandoNoExiste(rangoFechas, typeof(T));
DeleteFile <T>(rangoFechas);
}
