Example #1
0
        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
        {
            IndicadorViewModel indicadorViewModel = (IndicadorViewModel)value;

            if ((indicadorViewModel != null && indicadorViewModel.MetaAceptableViewModel != null) || indicadorViewModel.Id > 0)
            {
                IMedicionService medicionService = DependencyResolver.Current.GetService <IMedicionService>();

                EscalaGraficosViewModel escalas = medicionService.ObtenerEscalasGrafico(indicadorViewModel);

                decimal[] escalaValores = escalas.EscalaValores;

                if (escalaValores[0] <= escalaValores[1] &&
                    escalaValores[1] <= escalaValores[2] &&
                    escalaValores[2] <= escalaValores[3] &&
                    escalaValores[3] <= escalaValores[4] &&
                    escalaValores[4] <= escalaValores[5])
                {
                    return(null);
                }
                else
                {
                    return(new ValidationResult("Verifique que los rangos de las metas sean correctos."));
                }
            }
            else
            {
                return(null);
            }
        }
Example #2
0
 private bool HayCambios(Indicador indicadorOriginal, IndicadorViewModel indicadorCargado)
 {
     if (!indicadorOriginal.Nombre.Trim().Equals(indicadorCargado.Nombre.Trim()) ||
         !indicadorOriginal.Descripcion.Trim().Equals(indicadorCargado.Descripcion.Trim()))
     {
         return(true);
     }
     if (!indicadorOriginal.ObjetivoID.ToString().Trim().Equals(indicadorCargado.ObjetivoID.Trim()) ||
         !indicadorOriginal.FrecuenciaMedicionIndicadorID.ToString().Trim().Equals(indicadorCargado.FrecuenciaMedicionIndicadorID.Trim()))
     {
         return(true);
     }
     if (MetasDiferentes(indicadorOriginal.MetaAceptable, indicadorCargado.MetaAceptableViewModel) ||
         MetasDiferentes(indicadorOriginal.MetaAMejorar, indicadorCargado.MetaAMejorarViewModel) ||
         MetasDiferentes(indicadorOriginal.MetaExcelente, indicadorCargado.MetaExcelenteViewModel) ||
         MetasDiferentes(indicadorOriginal.MetaInaceptable, indicadorCargado.MetaInaceptableViewModel) ||
         MetasDiferentes(indicadorOriginal.MetaSatisfactoria, indicadorCargado.MetaSatisfactoriaViewModel))
     {
         return(true);
     }
     if (InteresadosDiferentes(indicadorOriginal.Interesados, indicadorCargado.Interesados))
     {
         return(true);
     }
     if (ResponsablesDiferentes(indicadorOriginal.Responsables, indicadorCargado.Responsables))
     {
         return(true);
     }
     return(false);
 }
Example #3
0
        public async Task <ActionResult> Crear(string idObjetivo)
        {
            IndicadorViewModel model = new IndicadorViewModel();

            model.Titulo        = "Indicadores";
            model.FechaCreacion = DateTime.Now.ToString("dd/MM/yyyy HH:mm tt");

            // Por el momento solo frecuencias mensuales
            model.FrecuenciaMedicionIndicadorViewModel = (await FrecuenciaMedicionIndicadorService.Buscar(new FrecuenciaMedicionIndicadorViewModel {
                Descripcion = "Mensual"
            })).FirstOrDefault();

            Session["InteresadosSeleccionados"]  = model.Interesados;
            Session["ResponsablesSeleccionados"] = model.Responsables;

            model.PersonaLogueadaViewModel = (PersonaViewModel)Session["Persona"];

            if (model.PersonaLogueadaViewModel.AreaViewModel != null)
            {
                model.ObjetivoViewModel.AreaViewModel = model.PersonaLogueadaViewModel.AreaViewModel;
                model.AreaID = model.ObjetivoViewModel.AreaViewModel.Id.ToString();
            }

            if (idObjetivo != null)
            {
                model.ObjetivoViewModel = await ObjetivoService.GetById(Int32.Parse(idObjetivo));
            }

            ViewBag.Titulo = model.Titulo;

            return(View(model));
        }
Example #4
0
        public async Task <ActionResult> Ver(string id, string msgExito)
        {
            IndicadorViewModel model = await IndicadorService.GetById(Int32.Parse(id));

            model.Titulo = "Indicadores";

            ViewBag.Titulo       = model.Titulo;
            ViewBag.MensageExito = msgExito;

            return(View(model));
        }
Example #5
0
        public IActionResult Put([FromBody] IndicadorViewModel indicador)
        {
            if (!ModelState.IsValid)
            {
                NotifyModelStateErrors();
                return(Response(indicador));
            }

            _indicadorAppService.Update(indicador);

            return(Response(indicador));
        }
Example #6
0
        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);
        }
Example #7
0
        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);
            }
        }
Example #8
0
        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);
        }
Example #9
0
        public async Task <ActionResult> Editar(string id, string msgExito)
        {
            IndicadorViewModel model = await IndicadorService.GetById(Int32.Parse(id));

            model.CantidadInteresadosElegidos  = model.Interesados.Count;
            model.CantidadResponsablesElegidos = model.Responsables.Count;
            model.PersonaLogueadaViewModel     = (PersonaViewModel)Session["Persona"];
            model.Titulo = "Indicadores";

            Session["InteresadosSeleccionados"]  = model.Interesados;
            Session["ResponsablesSeleccionados"] = model.Responsables;

            ViewBag.Titulo       = model.Titulo;
            ViewBag.MensageExito = msgExito;

            return(View(model));
        }
Example #10
0
        public async Task <ActionResult> Crear(IndicadorViewModel model)
        {
            model.PersonaLogueadaViewModel = (PersonaViewModel)Session["Persona"];

            if (model.PersonaLogueadaViewModel.AreaViewModel != null)
            {
                model.ObjetivoViewModel.AreaViewModel = model.PersonaLogueadaViewModel.AreaViewModel;
                model.AreaID = model.ObjetivoViewModel.AreaViewModel.Id.ToString();
            }

            model.FrecuenciaMedicionIndicadorViewModel = await FrecuenciaMedicionIndicadorService.GetById(Int32.Parse(model.FrecuenciaMedicionIndicadorID));

            if (!String.IsNullOrEmpty(model.ObjetivoID) && !model.ObjetivoID.Equals("0"))
            {
                model.ObjetivoViewModel = await ObjetivoService.GetById(Int32.Parse(model.ObjetivoID));
            }

            model.Interesados  = (IList <PersonaViewModel>)Session["InteresadosSeleccionados"];
            model.Responsables = (IList <PersonaViewModel>)Session["ResponsablesSeleccionados"];

            model.CantidadInteresadosElegidos  = model.Interesados.Count;
            model.CantidadResponsablesElegidos = model.Responsables.Count;

            if (!ModelState.IsValid)
            {
                ModelState.AddModelError(string.Empty, "Verifique que todos los campos estén cargados y sean correctos.");
                return(View(model));
            }

            model.Titulo = "Indicadores";

            ViewBag.Titulo = model.Titulo;

            PersonaViewModel persona = (PersonaViewModel)Session["Persona"];

            int idIndicador = await IndicadorService.Guardar(model, persona);

            object parametros = new { q = MyExtensions.Encrypt(new { id = idIndicador, msgExito = "El indicador se ha guardado exitosamente." }) };

            return(RedirectToAction("Editar", "Indicador", parametros));
        }
Example #11
0
        public void Register(IndicadorViewModel indicadorViewModel)
        {
            IEnumerable <IndicadorEscopoAreaViewModel> listIndicadorEscopoArea = new List <IndicadorEscopoAreaViewModel>();
            var registerCommand = _mapper.Map <CadastrarIndicadorCommand>(indicadorViewModel);

            registerCommand.Id = Guid.NewGuid();

            var result = Bus.SendCommand(registerCommand);

            if (result.IsCompleted)
            {
                listIndicadorEscopoArea = TransformaIndicadorEmIndicadorEscopoArea(indicadorViewModel);
            }

            foreach (var indicadorEscopoArea in listIndicadorEscopoArea)
            {
                indicadorEscopoArea.IndicadorId = registerCommand.Id;
                var registerEscopoAreaCommand = _mapper.Map <CadastrarIndicadorEscopoAreaCommand>(indicadorEscopoArea);
                Bus.SendCommand(registerEscopoAreaCommand);
            }
        }
Example #12
0
        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);
        }
Example #13
0
        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);
        }
Example #14
0
        public IEnumerable <IndicadorEscopoAreaViewModel> TransformaIndicadorEmIndicadorEscopoArea(IndicadorViewModel indicador)
        {
            var lista = new List <IndicadorEscopoAreaViewModel>();

            foreach (var indicadorEscopoAreaFor in indicador.IndicadorEscopoAreas)
            {
                var indicadorEscopoArea = new IndicadorEscopoAreaViewModel();
                indicadorEscopoArea.IndicadorId = indicadorEscopoAreaFor.Id;
                indicadorEscopoArea.EscopoId    = indicadorEscopoAreaFor.EscopoId;
                indicadorEscopoArea.AreaId      = indicadorEscopoAreaFor.AreaId;

                lista.Add(indicadorEscopoArea);
            }

            return(lista);
        }
Example #15
0
        public void Update(IndicadorViewModel indicadorViewModel)
        {
            var updateCommand = _mapper.Map <AtualizarIndicadorCommand>(indicadorViewModel);

            Bus.SendCommand(updateCommand);
        }
Example #16
0
        public EscalaGraficosViewModel ObtenerEscalasGrafico(IndicadorViewModel indicador)
        {
            EscalaGraficosViewModel escalas = new EscalaGraficosViewModel();

            decimal valorExcelente =
                ObtenerValorEscala(indicador.MetaExcelenteViewModel, indicador.MetaSatisfactoriaViewModel);

            decimal valorSatisfactorio =
                ObtenerValorEscala(indicador.MetaSatisfactoriaViewModel, indicador.MetaAceptableViewModel);

            decimal valorAceptable =
                ObtenerValorEscala(indicador.MetaAceptableViewModel, indicador.MetaAMejorarViewModel);

            decimal valorAMejorar =
                ObtenerValorEscala(indicador.MetaAMejorarViewModel, indicador.MetaInaceptableViewModel);

            if (valorExcelente >= valorSatisfactorio)
            {
                decimal minimoEscala = 0;

                if (!string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor1) &&
                    !string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor2))
                {
                    minimoEscala = decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ",")) < decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ",")) ? decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ",")) : decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ","));
                }
                else
                {
                    minimoEscala = string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor1) ? decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ",")) : decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ","));
                }

                decimal maximoEscala = 0;

                if (!string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor1) &&
                    !string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor2))
                {
                    maximoEscala = decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ",")) > decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ",")) ? decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ",")) : decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ","));
                }
                else
                {
                    maximoEscala = string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor1) ? decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ",")) : decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ","));
                }

                escalas.EscalaValores = new decimal[6] {
                    minimoEscala, valorAMejorar, valorAceptable, valorSatisfactorio, valorExcelente, maximoEscala
                };
                escalas.EscalaColores = ColorMetaInaceptableExcelente;
                escalas.EscalaDeInaceptableAExcelente = true;
            }
            else
            {
                decimal maximoEscala = 0;

                if (!string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor1) &&
                    !string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor2))
                {
                    maximoEscala = decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ",")) > decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ",")) ? decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ",")) : decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ","));
                }
                else
                {
                    maximoEscala = string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor1) ? decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ",")) : decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ","));
                }

                decimal minimoEscala = 0;

                if (!string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor1) &&
                    !string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor2))
                {
                    minimoEscala = decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ",")) < decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ",")) ? decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ",")) : decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ","));
                }
                else
                {
                    minimoEscala = string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor1) ? decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ",")) : decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ","));
                }

                escalas.EscalaValores = new decimal[6] {
                    minimoEscala, valorExcelente, valorSatisfactorio, valorAceptable, valorAMejorar, maximoEscala
                };
                escalas.EscalaColores = ColorMetaExcelenteInaceptable;
                escalas.EscalaDeInaceptableAExcelente = false;
            }

            return(escalas);
        }
Example #17
0
        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);
        }