Exemplo n.º 1
0
        public async Task <int> Guardar(IndicadorAutomatico indicadorAutomatico)
        {
            this.context.IndicadoresAutomaticos.AddOrUpdate(indicadorAutomatico);
            await this.context.SaveChangesAsync();

            return(indicadorAutomatico.Id);
        }
        private IIndicadorAutomaticoStrategy GetStrategy(int idIndicador)
        {
            IndicadorAutomatico automatico = IndicadorAutomaticoRepository.GetByIdIndicador(idIndicador).First();

            switch (automatico.CategoriaIndicadorAutomatico)
            {
            case Enums.Enum.CategoriaIndicadorAutomatico.CPI:
                return(IndicadorAutomaticoCPIStrategy);

            case Enums.Enum.CategoriaIndicadorAutomatico.CPI_Servicios:
                return(IndicadorAutomaticoCPIServiciosStrategy);

            case Enums.Enum.CategoriaIndicadorAutomatico.CPI_Llave_En_Mano:
                return(IndicadorAutomaticoCPILlaveManoStrategy);

            default:
                return(null);
            }
        }
Exemplo n.º 3
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);
        }