public async Task Get_ShouldReturnResponseIndicadorWithAllObj()
{
//Arrange:
ExternalApiContext api = new ExternalApiContext();
IIndicadorRepository _contextDA = new IndicadorRepository(api);
IndicadorActions _contextActions = new IndicadorActions(_contextDA);
IndicadorController pController = new IndicadorController(_contextActions);
FiltroIndicador param = new FiltroIndicador {
TipoIndicador = ""
};
//Act:
Response <Indicador_Entity> response = await pController.Get(param);
//CollectionAssert:
var responseErrorCode = response.CodigoError;
var responseSystemMsg = response.MensajeSistema;
var responseHumanMsg = response.MensajeHumano;
var responseList = response.Contenido;
Assert.AreEqual("E00", responseErrorCode);
Assert.AreEqual("Record(s) found", responseSystemMsg);
Assert.AreEqual("Consulta exitosa!", responseHumanMsg);
}
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> GetById(int id)
{
Indicador indicador = await IndicadorRepository.GetById(id).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 <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 <int> Guardar(IndicadorViewModel indicadorViewModel, PersonaViewModel personaGuarda)
{
bool modificado = false;
int mesActual = DateTimeHelper.OntenerFechaActual().Month;
int idIndicadorOriginal = 0;
if (indicadorViewModel.Id > 0)
{
Indicador indicadorOriginal = IndicadorRepository.GetById(indicadorViewModel.Id).First();
if (HayCambios(indicadorOriginal, indicadorViewModel) && await MedicionRepository.Buscar(new MedicionViewModel {
IndicadorID = indicadorViewModel.Id
}).AnyAsync(m => (int)m.Mes != mesActual))
{
idIndicadorOriginal = indicadorViewModel.Id;
indicadorViewModel.Id = 0;
modificado = true;
}
}
// Borrar los responsables previos
await ResponsableIndicadorRepository.EliminarPorIndicador(indicadorViewModel.Id);
// Borrar los interesados previos
await InteresadoIndicadorRepository.EliminarPorIndicador(indicadorViewModel.Id);
// Borrar los permisos previos
await AccesoIndicadorRepository.EliminarPorIndicador(indicadorViewModel.Id);
Indicador indicador = AutoMapper.Mapper.Map <Indicador>(indicadorViewModel);
if (modificado)
{
indicador.FechaCreacion = indicador.FechaCreacion.Value.AddMinutes(1);
}
indicador.MetaAceptableMetaID = await GuardarMeta(indicadorViewModel.MetaAceptableViewModel);
indicador.MetaAMejorarMetaID = await GuardarMeta(indicadorViewModel.MetaAMejorarViewModel);
indicador.MetaExcelenteMetaID = await GuardarMeta(indicadorViewModel.MetaExcelenteViewModel);
indicador.MetaInaceptableMetaID = await GuardarMeta(indicadorViewModel.MetaInaceptableViewModel);
indicador.MetaSatisfactoriaMetaID = await GuardarMeta(indicadorViewModel.MetaSatisfactoriaViewModel);
// Guardar el indicador
await IndicadorRepository.Guardar(indicador);
if (indicador.Grupo == 0)
{
indicador.Grupo = indicador.IndicadorID;
await IndicadorRepository.Guardar(indicador);
}
if (modificado)
{
IndicadorAutomatico indicadorAutomatico = await IndicadorAutomaticoRepository.GetByIdIndicador(idIndicadorOriginal).FirstOrDefaultAsync();
if (indicadorAutomatico != null)
{
indicadorAutomatico.Indicador = null;
indicadorAutomatico.IndicadorID = indicador.IndicadorID;
await IndicadorAutomaticoRepository.Guardar(indicadorAutomatico);
IndicadorAutomaticoViewModel indicadorAutomaticoViewModel = AutoMapper.Mapper.Map <IndicadorAutomaticoViewModel>(indicadorAutomatico);
IndicadorAutomaticoRepository.DetenerJob(indicadorAutomaticoViewModel);
IndicadorAutomaticoRepository.IniciarJob(indicadorAutomaticoViewModel);
}
}
// Guardar los responsables
await GuardarResponsables(indicadorViewModel.Responsables, indicador.IndicadorID);
// Guardar los interesados
await GuardarInteresados(indicadorViewModel.Interesados, indicador.IndicadorID);
if (modificado)
{
// Si hay mediciones cargadas para el indicador que se esta modificando, actualizar la referencia al nuevo indicador
IList <Medicion> mediciones = MedicionRepository.Buscar(new MedicionViewModel {
IndicadorID = idIndicadorOriginal, Mes = (Enums.Enum.Mes)mesActual
}).ToList();
if (mediciones != null && mediciones.Count > 0)
{
foreach (Medicion medicion in mediciones)
{
medicion.IndicadorID = indicador.IndicadorID;
await MedicionRepository.Guardar(medicion);
}
}
}
await AuditarModificacionIndicador(personaGuarda);
return(indicador.IndicadorID);
}
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);
}
