Ejemplo n.º 1
0
        private async Task GuardarInteresados(IList <PersonaViewModel> interesados, int indicadorID)
        {
            if (interesados != null)
            {
                foreach (PersonaViewModel interesado in interesados)
                {
                    // Guardar a la persona
                    InteresadoIndicador interesadoIndicador = new InteresadoIndicador();
                    interesadoIndicador.IndicadorID = indicadorID;
                    interesadoIndicador.PersonaID   = interesado.Id;
                    await InteresadoIndicadorRepository.Guardar(interesadoIndicador);

                    // Guardar los permisos
                    AccesoIndicador acceso = new AccesoIndicador();
                    acceso.IndicadorID      = indicadorID;
                    acceso.PersonaID        = interesado.Id;
                    acceso.PermisoIndicador = Enums.Enum.PermisoIndicador.SoloLectura;
                    await AccesoIndicadorRepository.Guardar(acceso);
                }
            }
        }
Ejemplo n.º 2
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);
        }