public async Task <GaugeViewModel> ObtenerGaugeViewModel(long grupo, int anio, PersonaViewModel personaViewModel, bool todasLasAreas = false)
{
MedicionViewModel filtro = new MedicionViewModel();
filtro.Grupo = grupo;
filtro.Anio = anio;
filtro.BuscarPorNoAplica = true;
filtro.NoAplica = false;
IList <MedicionViewModel> medicionesViewModel = await Buscar(filtro);
GaugeViewModel gaugeViewModel = new GaugeViewModel();
if (medicionesViewModel != null && medicionesViewModel.Count > 0)
{
MedicionViewModel ultimaMedicionCargada = medicionesViewModel.OrderBy(m => m.Mes).Reverse().First();
// Obtener el último indicador
Indicador ultimoIndicador = IndicadorRepository.Buscar(new BuscarIndicadorViewModel {
Busqueda = new IndicadorViewModel {
Grupo = grupo
}, PersonaLogueadaViewModel = personaViewModel, TodasLasAreas = todasLasAreas
}).First();
gaugeViewModel.NombreMes = ultimaMedicionCargada.Mes.ToString();
gaugeViewModel.NombreIndicador = ultimoIndicador.Nombre;
gaugeViewModel.Valor = ultimaMedicionCargada.Valor;
CompletarEscalasGauge(gaugeViewModel, ultimaMedicionCargada);
}
return(gaugeViewModel);
}
public async Task <IndicadorViewModel> GetUltimoByGrupo(long grupo, PersonaViewModel personaViewModel, bool buscarTodasLasAreas = false)
{
// Obtener el nombre del último indicador del grupo.
Indicador indicador = await IndicadorRepository.Buscar(new BuscarIndicadorViewModel { Busqueda = new IndicadorViewModel {
Grupo = grupo
}, PersonaLogueadaViewModel = personaViewModel, TodasLasAreas = buscarTodasLasAreas }).FirstAsync();
IndicadorViewModel indicadorViewModel = AutoMapper.Mapper.Map <IndicadorViewModel>(indicador);
indicadorViewModel.ObjetivoViewModel = AutoMapper.Mapper.Map <ObjetivoViewModel>(indicador.Objetivo);
indicadorViewModel.ObjetivoViewModel.AreaViewModel = AutoMapper.Mapper.Map <AreaViewModel>(indicador.Objetivo.Area);
indicadorViewModel.FrecuenciaMedicionIndicadorViewModel = AutoMapper.Mapper.Map <FrecuenciaMedicionIndicadorViewModel>(indicador.FrecuenciaMedicion);
indicadorViewModel.Interesados = AutoMapper.Mapper.Map <IList <PersonaViewModel> >(indicador.Interesados.Select(i => i.Persona));
indicadorViewModel.Responsables = AutoMapper.Mapper.Map <IList <PersonaViewModel> >(indicador.Responsables.Select(i => i.Persona));
return(indicadorViewModel);
}
public async Task <HeatMapViewModel> ObtenerHeatMapViewModel(BuscarIndicadorViewModel buscarIndicadorViewModel)
{
Persona persona = await PersonaRepository.GetByUserName(buscarIndicadorViewModel.PersonaLogueadaViewModel.NombreUsuario).FirstOrDefaultAsync();
IList <IndicadorAutomaticoViewModel> todosIndicadoresAutomaticos = AutoMapper.Mapper.Map <IList <IndicadorAutomaticoViewModel> >(IndicadorAutomaticoRepository.Todos().ToList());
IList <FilaHeatMapViewModel> filasHeatMapViewModel = AutoMapper.Mapper.Map <IList <FilaHeatMapViewModel> >(IndicadorRepository.Buscar(buscarIndicadorViewModel).ToList());
CargarPermisosAIndicadores(filasHeatMapViewModel, persona);
IList <MedicionViewModel> mediciones = await Todas(buscarIndicadorViewModel.AnioTablero);
IList <CeldaHeatMapViewModel> celdasHeatMapViewModel = new List <CeldaHeatMapViewModel>();
HeatMapViewModel heatMapViewModel = new HeatMapViewModel();
heatMapViewModel.Meses = Enum.GetValues(typeof(Enums.Enum.Mes)).Cast <Enums.Enum.Mes>().Select(v => v.ToString()).ToList();
heatMapViewModel.FilasHeatMapViewModel = filasHeatMapViewModel;
DateTime fechaActual = DateTimeHelper.OntenerFechaActual();
foreach (Enums.Enum.Mes mes in Enum.GetValues(typeof(Enums.Enum.Mes)).Cast <Enums.Enum.Mes>())
{
if ((int)mes <= fechaActual.Month || buscarIndicadorViewModel.AnioTablero < fechaActual.Year)
{
IList <MedicionViewModel> medicionesPorMes = mediciones.Where(m => m.Mes == mes).OrderBy(m => m.IndicadorViewModel.Id).ToList();
int i = 0;
while (i < filasHeatMapViewModel.Count)
{
FilaHeatMapViewModel indicador = filasHeatMapViewModel[i];
if (
(indicador.FechaInicioValidez == null ||
(indicador.FechaInicioValidez != null &&
(
(indicador.FechaInicioValidez.Value.Year < buscarIndicadorViewModel.AnioTablero) ||
(
indicador.FechaInicioValidez.Value.Year == buscarIndicadorViewModel.AnioTablero &&
indicador.FechaInicioValidez.Value.Month <= (int)mes
)
)
)
) &&
(
indicador.FechaFinValidez == null ||
(indicador.FechaFinValidez != null &&
(
(indicador.FechaFinValidez.Value.Year > buscarIndicadorViewModel.AnioTablero) ||
(
indicador.FechaFinValidez.Value.Year == buscarIndicadorViewModel.AnioTablero &&
indicador.FechaFinValidez.Value.Month >= (int)mes
)
)
)
)
)
{
CeldaHeatMapViewModel celdaHeatMapViewModel = new CeldaHeatMapViewModel();
celdaHeatMapViewModel.IndiceIndicador = i + 1;
celdaHeatMapViewModel.Mes = (int)mes;
celdaHeatMapViewModel.IdIndicador = indicador.IdIndicador;
celdaHeatMapViewModel.GrupoIndicador = indicador.Grupo;
celdaHeatMapViewModel.NombreMes = mes.ToString();
celdaHeatMapViewModel.NombreIndicador = indicador.NombreIndicador;
celdaHeatMapViewModel.TieneAccesoLecturaEscritura = indicador.TieneAccesoLecturaEscritura;
celdaHeatMapViewModel.EsAutomatico = todosIndicadoresAutomaticos.Any(ia => ia.IndicadorViewModel.Grupo == celdaHeatMapViewModel.GrupoIndicador);
if (medicionesPorMes.Any(m => m.IndicadorViewModel.Grupo == indicador.Grupo && m.Mes == mes))
{
MedicionViewModel medicionPorMes = medicionesPorMes.First(m => m.IndicadorViewModel.Grupo == indicador.Grupo && m.Mes == mes);
celdaHeatMapViewModel.IdMedicion = medicionPorMes.MedicionId;
if (!medicionPorMes.NoAplica)
{
celdaHeatMapViewModel.Medicion = medicionPorMes.Valor;
celdaHeatMapViewModel.ColorMeta = ObtenerColorCeldaHeatMap(medicionPorMes);
celdaHeatMapViewModel.MedicionCargada = true;
}
else
{
celdaHeatMapViewModel.NoAplica = true;
}
}
celdasHeatMapViewModel.Add(celdaHeatMapViewModel);
}
i++;
}
}
}
heatMapViewModel.Celdas = celdasHeatMapViewModel;
return(heatMapViewModel);
}
public async Task NotificarCarga()
{
try
{
DateTime fechaActual = DateTimeHelper.OntenerFechaActual();
if (fechaActual.Day >= 1)
{
Dictionary <Persona, IList <Indicador> > avisos = new Dictionary <Persona, IList <Indicador> >();
int anio = fechaActual.Year;
int mes = fechaActual.Month;
if (mes == 1)
{
anio -= 1;
mes = 12;
}
else
{
mes -= 1;
}
IList <Indicador> indicadores = await IndicadorRepository.Buscar(new BuscarIndicadorViewModel { AnioTablero = anio }).ToListAsync();
IList <IndicadorAutomaticoViewModel> todosIndicadoresAutomaticos = this.IndicadorAutomaticoService.Todos();
foreach (Indicador indicador in indicadores)
{
if (!todosIndicadoresAutomaticos.Any(ia => ia.IndicadorViewModel.Grupo == indicador.Grupo) &&
(indicador.FechaFinValidez == null || indicador.FechaFinValidez.Value.Month >= mes) &&
(indicador.FechaInicioValidez == null || indicador.FechaInicioValidez.Value.Month <= mes))
{
List <Medicion> mediciones = await MedicionRepository.Buscar(new MedicionViewModel { Grupo = indicador.Grupo, Anio = anio, Mes = EnumHelper <Enums.Enum.Mes> .Parse(mes.ToString()) }).ToListAsync();
if (mediciones == null || mediciones.Count == 0)
{
IList <Persona> personasAAvisar = new List <Persona>();
personasAAvisar = personasAAvisar.Union(indicador.Responsables.Select(i => i.Persona).ToList()).ToList();
personasAAvisar = personasAAvisar.Union(await PersonaRepository.Buscar(new PersonaViewModel {
EsUsuario = true, AreaViewModel = new AreaViewModel {
Id = indicador.Objetivo.AreaID
}
}).ToListAsync()).ToList();
personasAAvisar = personasAAvisar.Distinct(new PersonaComparer()).ToList();
foreach (Persona personaAAvisar in personasAAvisar)
{
if (avisos.ContainsKey(personaAAvisar))
{
avisos[personaAAvisar].Add(indicador);
}
else
{
IList <Indicador> indicadorAviso = new List <Indicador>();
indicadorAviso.Add(indicador);
avisos.Add(personaAAvisar, indicadorAviso);
}
}
}
}
}
IMailStrategy mailStrategy = ObtenerMailStrategy();
foreach (Persona persona in avisos.Keys)
{
DataTable tabla = new DataTable();
tabla.Columns.Add("Área", typeof(string));
tabla.Columns.Add("Indicador", typeof(string));
tabla.Columns.Add("Mes", typeof(string));
foreach (Indicador indicador in avisos[persona])
{
tabla.Rows.Add(indicador.Objetivo.Area.Nombre,
indicador.Nombre,
EnumHelper <Enums.Enum.Mes> .Parse(mes.ToString()).ToString());
}
try
{
string cuerpoMail = CrearTablaHtmlCargaMediciones(tabla, persona.NombreApellido).ToString();
await mailStrategy.EnviarCorreo(persona.Email, "[Y U T P L A T] Indicadores incompletos", cuerpoMail);
}
catch (Exception ex)
{
LogHelper.LogException(ex);
}
}
}
}
catch (Exception ex)
{
LogHelper.LogException(ex);
}
}
public async Task <IList <IndicadorViewModel> > Buscar(BuscarIndicadorViewModel filtro)
{
Persona persona = await PersonaRepository.GetByUserName(filtro.PersonaLogueadaViewModel.NombreUsuario).FirstOrDefaultAsync();
IList <IndicadorViewModel> indicadores = AutoMapper.Mapper.Map <IList <IndicadorViewModel> >(IndicadorRepository.Buscar(filtro).ToList());
CargarPermisosAIndicadores(indicadores, persona);
return(indicadores);
}
