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 IQueryable <Medicion> Buscar(MedicionViewModel filtro)
{
IQueryable <Medicion> queryable = this.context.Mediciones;
if (filtro.Grupo > 0)
{
queryable = queryable.Where(a => a.Indicador.Grupo == filtro.Grupo);
}
if (filtro.IndicadorID > 0)
{
queryable = queryable.Where(m => m.IndicadorID == filtro.IndicadorID);
}
if (filtro.Mes > 0)
{
queryable = queryable.Where(m => m.Mes == filtro.Mes);
}
if (filtro.Anio > 0)
{
queryable = queryable.Where(m => m.Anio == filtro.Anio);
}
if (filtro.SeDebeNotificar != null)
{
queryable = queryable.Where(m => m.SeDebeNotificar == filtro.SeDebeNotificar.Value);
}
if (filtro.BuscarPorNoAplica)
{
queryable = queryable.Where(m => m.NoAplica == filtro.NoAplica);
}
return(queryable);
}
public int GuardarMedicionNoTask(MedicionViewModel medicionViewModel)
{
if (!medicionViewModel.NoAplica)
{
Medicion medicionActual = MedicionRepository.GetById(medicionViewModel.MedicionId).FirstOrDefault();
string colorActual = null;
if (medicionActual != null)
{
MedicionViewModel medicionViewModelActual = AutoMapper.Mapper.Map <MedicionViewModel>(medicionActual);
colorActual = ObtenerColorCeldaHeatMap(medicionViewModelActual);
}
string colorNuevo = ObtenerColorCeldaHeatMap(medicionViewModel);
if (colorNuevo.Equals(Inaceptable))
{
if (colorActual == null || !colorActual.Equals(colorNuevo))
{
medicionViewModel.SeDebeNotificar = true;
}
}
}
Medicion medicion = AutoMapper.Mapper.Map <Medicion>(medicionViewModel);
medicion.Indicador = null;
return(MedicionRepository.GuardarNoTask(medicion));
}
public async Task <ActionResult> AbrirModalCargaMedicion(int idIndicador, int mes, int idAnio, int?idMedicion, long grupo, bool tieneAccesoEscritura, bool esAutomatico)
{
LimpiarSession();
PersonaViewModel personaViewModel = (PersonaViewModel)Session["Persona"];
AnioTableroViewModel anioViewModel = await AnioTableroService.GetById(idAnio);
MedicionViewModel medicionViewModel = await MedicionService.ObtenerMedicionViewModel(idIndicador, mes, idMedicion, grupo, anioViewModel.Anio, personaViewModel, true);
medicionViewModel.EsIndicadorAutomatico = esAutomatico;
DateTime fechaActual = DateTimeHelper.OntenerFechaActual();
string view = "Medicion/_Crear";
if (
(anioViewModel.Anio != fechaActual.Year && !(fechaActual.Month == 1 && mes == 12))
||
(!personaViewModel.EsJefeArea && !tieneAccesoEscritura)
||
(!tieneAccesoEscritura && personaViewModel.EsJefeArea && !personaViewModel.AreaViewModel.Id.ToString().Equals(medicionViewModel.IndicadorViewModel.AreaID))
)
{
view = "Medicion/_Ver";
}
else if (esAutomatico)
{
view = "Medicion/_CrearAutomatico";
}
Session["FrenarRevision_" + personaViewModel.NombreUsuario] = true;
return(PartialView(view, medicionViewModel));
}
private string ObtenerColorCeldaHeatMap(MedicionViewModel medicion)
{
EscalaGraficosViewModel escalas = ObtenerEscalasGrafico(medicion.IndicadorViewModel);
decimal valor = escalas.EscalaValores[0];
int i = 0;
decimal valorMedicion = decimal.Parse(medicion.Valor.Replace(".", ","));
while (valorMedicion >= valor && i < 5)
{
i++;
valor = escalas.EscalaValores[i];
}
if (i == 0)
{
i++;
}
int j = DesempatarColor(medicion, escalas);
if (j > 0)
{
i = j;
}
return(escalas.EscalaColores[i - 1]);
}
protected void btnCrearMedicion_Click(object sender, EventArgs e)
{
if (lstSensores.Items.Count == 0)
{
lblResult.ForeColor = System.Drawing.Color.Red;
lblResult.Text = "No hay sensores disponibles, por favor busque en otra plantacion";
return;
}
var fechaDesde = DateTimeOffset.Parse(calendarFecha.SelectedDate.ToShortDateString() + " " + txtHoraDesde.Text + " " + ddlDesdeAMPM.Text);
MedicionViewModel medicion = new MedicionViewModel
{
Descripcion = "Ingresada manualmente",
Fecha = fechaDesde,
FrutoId = Convert.ToInt32(ddlFruto.SelectedValue),
PlantacionId = Convert.ToInt32(ddlPlantacion.SelectedValue),
SensorId = Convert.ToInt32(lstSensores.SelectedValue),
Porcentaje = Convert.ToDecimal(txtPorcentaje.Text),
UsuarioId = this.Usuario.Id
};
int medicionId = _MedicionService.CrearMedicion(medicion);
if (medicionId > 0)
{
lblResult.ForeColor = System.Drawing.Color.Green;
lblResult.Text = "La medicion " + medicionId + " de " + medicion.Porcentaje.ToString() + "% ha sido creada con exito para el dia " + fechaDesde.ToString("MM/dd/yyyy h:mm tt") + " en el Sensor " + medicion.SensorId;
BindPlantaciones();
}
else
{
lblResult.ForeColor = System.Drawing.Color.Red;
lblResult.Text = "Ha ocurrido un error al crear la medicion, intentelo nuevamente";
}
}
public async Task <int> Guardar(MedicionViewModel medicionViewModel)
{
Medicion medicion = AutoMapper.Mapper.Map <Medicion>(medicionViewModel);
medicion.Indicador = null;
return(await MedicionRepository.Guardar(medicion));
}
public FrmMedicionGrid()
{
InitializeComponent();
Model = ServiceLocator.Instance.Resolve <MedicionViewModel>();
Model.Page = -1;
Model.Opcion = 1;
this.btnEditarLista.FlatAppearance.BorderSize = 1;
this.btnElimiarLista.FlatAppearance.BorderSize = 1;
this.BtnSeleccionar.FlatAppearance.BorderSize = 1;
}
public async Task <IList <LineViewModel> > ObtenerLineViewModel(long grupo, int anio, PersonaViewModel personaViewModel)
{
MedicionViewModel filtro = new MedicionViewModel();
filtro.Grupo = grupo;
filtro.Anio = anio;
filtro.BuscarPorNoAplica = true;
filtro.NoAplica = false;
return(AutoMapper.Mapper.Map <IList <LineViewModel> >((await MedicionRepository.Buscar(filtro).ToListAsync()).OrderBy(m => m.Mes)));
}
public void EjecutarIndicador(IndicadorViewModel indicadorViewModel)
{
lock (thisLock)
{
int mesACalcular = 0;
int anioACalcular = 0;
if (DateTimeHelper.OntenerFechaActual().Month == 1)
{
mesACalcular = 12;
anioACalcular = DateTimeHelper.OntenerFechaActual().Year - 1;
}
else
{
mesACalcular = DateTimeHelper.OntenerFechaActual().Month - 1;
anioACalcular = DateTimeHelper.OntenerFechaActual().Year;
}
// Calcular las mediciones del mes anterior
Enums.Enum.Mes mesAnterior = Helpers.EnumHelper <Enums.Enum.Mes> .Parse(mesACalcular.ToString());
MedicionViewModel medicionMes = GetMedicionService().BuscarNoTask(new MedicionViewModel {
Grupo = indicadorViewModel.Grupo, Mes = mesAnterior, Anio = anioACalcular
}).FirstOrDefault();
IList <MedicionResultDTO> medicionesNuevas = null;
// Guardar la medición sólo si no tiene
if (medicionMes == null)
{
medicionesNuevas = ObtenerDetallesMediciones(mesACalcular, anioACalcular);
medicionMes = GetMedicionService().ObtenerMedicionViewModelNoTask(indicadorViewModel.Id, (int)mesAnterior, null, indicadorViewModel.Grupo, anioACalcular, null);
medicionMes.FechaCarga = DateTimeHelper.OntenerFechaActual().ToString("dd/MM/yyyy HH:mm tt");
medicionMes.UsuarioCargo = "Automático Sistema";
medicionMes.Anio = anioACalcular;
medicionMes.Valor = ObtenerValorMedicionCPI(medicionesNuevas).ToString().Replace(",", ".").TrimEnd('0').TrimEnd('.');
if (string.IsNullOrEmpty(medicionMes.Valor))
{
medicionMes.Valor = "0";
}
medicionMes.MedicionId = GetMedicionService().GuardarMedicionNoTask(medicionMes);
}
// Generar excel con el detalle
GenerarExcel((int)medicionMes.Mes, medicionMes.Anio, indicadorViewModel.Id, (List <MedicionResultDTO>)medicionesNuevas);
}
}
public MedicionViewModel GetMedicionById(int medicionId)
{
MedicionViewModel queryResult = new MedicionViewModel();
try
{
var request = new RestRequest(getMedicionById, Method.GET);
request.AddParameter("medicionId", medicionId);
queryResult = client.Execute <MedicionViewModel>(request).Data;
}
catch (Exception ex)
{
return(null);
}
return(queryResult);
}
public async Task <ActionResult> CargarMedicionAutomatica(MedicionViewModel model)
{
if (!ModelState.IsValidField("Valor") ||
!ModelState.IsValidField("Comentario") ||
!MedicionService.ValidaMedicion(model))
{
ModelState.AddModelError(string.Empty, "Verifique que todos los campos estén cargados y sean correctos.");
return(PartialView("Medicion/_CrearAutomatico", model));
}
LimpiarSession();
model.Anio = (await AnioTableroService.GetById(Int32.Parse((string)Session["IdAnioTablero"]))).Anio;
model.FechaCarga = DateTimeHelper.OntenerFechaActual().ToString("dd/MM/yyyy HH:mm tt");
model.UsuarioCargo = User.Identity.Name;
await MedicionService.GuardarMedicion(model);
return(Json(new { success = true }));
}
private void CompletarEscalasGauge(GaugeViewModel gauge, MedicionViewModel medicion)
{
EscalaGraficosViewModel escalas = ObtenerEscalasGrafico(medicion.IndicadorViewModel);
gauge.Escala = escalas.EscalaValores;
gauge.Colores = escalas.EscalaColores;
if (decimal.Parse(gauge.Valor.Replace(".", ",")) < gauge.Escala[0])
{
string valor = (gauge.Escala[0] != 0 ? gauge.Escala[0].ToString().Replace(",", ".") : "0");
valor = (valor.Contains(".") ? valor.TrimEnd('0').TrimEnd('.') : valor);
gauge.Valor = valor;
}
else if (decimal.Parse(gauge.Valor.Replace(".", ",")) > gauge.Escala[5])
{
string valor = (gauge.Escala[5] != 0 ? gauge.Escala[5].ToString().Replace(",", ".") : "0");
valor = (valor.Contains(".") ? valor.TrimEnd('0').TrimEnd('.') : valor);
gauge.Valor = valor;
}
}
public async Task <MedicionViewModel> ObtenerMedicionViewModel(int idIndicador, int mes, int?idMedicion, long grupo, int anio, PersonaViewModel personaViewModel, bool buscarTodasLasAreas = false)
{
MedicionViewModel medicionViewModel = new MedicionViewModel();
medicionViewModel.Mes = Helpers.EnumHelper <Enums.Enum.Mes> .Parse(mes.ToString());
medicionViewModel.IndicadorID = idIndicador;
// Obtener el nombre del último indicador del grupo.
IndicadorViewModel indicadorViewModel = await IndicadorService.GetUltimoByGrupo(grupo, personaViewModel, buscarTodasLasAreas);
if (idMedicion != null)
{
medicionViewModel = await this.GetById(idMedicion.Value);
}
else
{
medicionViewModel.IndicadorViewModel = indicadorViewModel;
}
medicionViewModel.IndicadorViewModel.Nombre = indicadorViewModel.Nombre;
return(medicionViewModel);
}
public MedicionViewModel ObtenerMedicionViewModelNoTask(int idIndicador, int mes, int?idMedicion, long grupo, int anio, PersonaViewModel personaViewModel)
{
MedicionViewModel medicionViewModel = new MedicionViewModel();
medicionViewModel.Mes = Helpers.EnumHelper <Enums.Enum.Mes> .Parse(mes.ToString());
medicionViewModel.IndicadorID = idIndicador;
// Obtener el nombre del último indicador del grupo.
IndicadorViewModel indicadorViewModel = IndicadorService.GetUltimoByGrupoNoTask(grupo, personaViewModel);
if (idMedicion != null)
{
medicionViewModel = this.GetByIdNoTask(idMedicion.Value);
}
else
{
medicionViewModel.IndicadorViewModel = indicadorViewModel;
}
medicionViewModel.IndicadorViewModel.Nombre = indicadorViewModel.Nombre;
return(medicionViewModel);
}
public int CrearMedicion(MedicionViewModel medicion)
{
int queryResult;
try
{
var request = new RestRequest(crearMedicion, Method.POST);
//request.AddParameter("reservaId", reservaId);
request.RequestFormat = DataFormat.Json;
request.AddBody(medicion);
//client.Execute(request);
queryResult = client.Execute <int>(request).Data;
}
catch (Exception ex)
{
return(0);
}
return(queryResult);
}
public async Task <IActionResult> CrearMedicion([FromBody] MedicionViewModel medicion)
{
var medicionAgregada = await _MedicionService.Add(medicion);
return(Ok(medicionAgregada));
}
private int DesempatarColor(MedicionViewModel medicion, EscalaGraficosViewModel escalas)
{
decimal valorMedicion = decimal.Parse(medicion.Valor.Replace(".", ","));
int i = -1;
if (escalas.EscalaDeInaceptableAExcelente)
{
Meta meta = AutoMapper.Mapper.Map <Meta>(medicion.IndicadorViewModel.MetaInaceptableViewModel);
bool estaEnLaMeta = ValorEnLaMeta(meta, valorMedicion);
if (estaEnLaMeta)
{
i = 1;
}
else
{
meta = AutoMapper.Mapper.Map <Meta>(medicion.IndicadorViewModel.MetaAMejorarViewModel);
estaEnLaMeta = ValorEnLaMeta(meta, valorMedicion);
if (estaEnLaMeta)
{
i = 2;
}
else
{
meta = AutoMapper.Mapper.Map <Meta>(medicion.IndicadorViewModel.MetaAceptableViewModel);
estaEnLaMeta = ValorEnLaMeta(meta, valorMedicion);
if (estaEnLaMeta)
{
i = 3;
}
else
{
meta = AutoMapper.Mapper.Map <Meta>(medicion.IndicadorViewModel.MetaSatisfactoriaViewModel);
estaEnLaMeta = ValorEnLaMeta(meta, valorMedicion);
if (estaEnLaMeta)
{
i = 4;
}
else
{
meta = AutoMapper.Mapper.Map <Meta>(medicion.IndicadorViewModel.MetaExcelenteViewModel);
estaEnLaMeta = ValorEnLaMeta(meta, valorMedicion);
if (estaEnLaMeta)
{
i = 5;
}
}
}
}
}
}
else
{
Meta meta = AutoMapper.Mapper.Map <Meta>(medicion.IndicadorViewModel.MetaExcelenteViewModel);
bool estaEnLaMeta = ValorEnLaMeta(meta, valorMedicion);
if (estaEnLaMeta)
{
i = 1;
}
else
{
meta = AutoMapper.Mapper.Map <Meta>(medicion.IndicadorViewModel.MetaSatisfactoriaViewModel);
estaEnLaMeta = ValorEnLaMeta(meta, valorMedicion);
if (estaEnLaMeta)
{
i = 2;
}
else
{
meta = AutoMapper.Mapper.Map <Meta>(medicion.IndicadorViewModel.MetaAceptableViewModel);
estaEnLaMeta = ValorEnLaMeta(meta, valorMedicion);
if (estaEnLaMeta)
{
i = 3;
}
else
{
meta = AutoMapper.Mapper.Map <Meta>(medicion.IndicadorViewModel.MetaAMejorarViewModel);
estaEnLaMeta = ValorEnLaMeta(meta, valorMedicion);
if (estaEnLaMeta)
{
i = 4;
}
else
{
meta = AutoMapper.Mapper.Map <Meta>(medicion.IndicadorViewModel.MetaInaceptableViewModel);
estaEnLaMeta = ValorEnLaMeta(meta, valorMedicion);
if (estaEnLaMeta)
{
i = 5;
}
}
}
}
}
}
return(i);
}
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 bool ValidaMedicion(MedicionViewModel medicionViewModel)
{
if (medicionViewModel.NoAplica)
{
return(true);
}
EscalaGraficosViewModel escalas = ObtenerEscalasGrafico(medicionViewModel.IndicadorViewModel);
decimal valor = escalas.EscalaValores[0];
int i = 0;
decimal valorMedicion = decimal.Parse(medicionViewModel.Valor.Replace(".", ","));
while (valorMedicion >= valor && i < 5)
{
i++;
valor = escalas.EscalaValores[i];
}
if (i == 0)
{
i++;
}
int j = DesempatarColor(medicionViewModel, escalas);
if (j > 0)
{
i = j;
}
if (i == 1 || i == 5)
{
if (escalas.EscalaDeInaceptableAExcelente)
{
if (i == 1)
{
Meta meta = AutoMapper.Mapper.Map <Meta>(medicionViewModel.IndicadorViewModel.MetaInaceptableViewModel);
return(ValidaMedicionBorde(meta, valorMedicion));
}
else
{
Meta meta = AutoMapper.Mapper.Map <Meta>(medicionViewModel.IndicadorViewModel.MetaExcelenteViewModel);
return(ValidaMedicionBorde(meta, valorMedicion));
}
}
else
{
if (i == 1)
{
Meta meta = AutoMapper.Mapper.Map <Meta>(medicionViewModel.IndicadorViewModel.MetaExcelenteViewModel);
return(ValidaMedicionBorde(meta, valorMedicion));
}
else
{
Meta meta = AutoMapper.Mapper.Map <Meta>(medicionViewModel.IndicadorViewModel.MetaInaceptableViewModel);
return(ValidaMedicionBorde(meta, valorMedicion));
}
}
}
else
{
return(true);
}
}
public async Task <IList <MedicionViewModel> > Buscar(MedicionViewModel filtro)
{
return(AutoMapper.Mapper.Map <IList <MedicionViewModel> >(await MedicionRepository.Buscar(filtro).ToListAsync()));
}
public IList <MedicionViewModel> BuscarNoTask(MedicionViewModel filtro)
{
return(AutoMapper.Mapper.Map <IList <MedicionViewModel> >(MedicionRepository.Buscar(filtro).ToList()));
}
