Пример #1
0
        public void IniciarJob(IndicadorAutomaticoViewModel indicadorAutomatico)
        {
            switch (indicadorAutomatico.CategoriaIndicadorAutomatico)
            {
            case Enums.Enum.CategoriaIndicadorAutomatico.CPI:
                RecurringJob.AddOrUpdate <IndicadorAutomaticoCPIStrategy>(
                    indicadorAutomatico.Nombre,
                    x => x.EjecutarIndicador(indicadorAutomatico.IndicadorViewModel),
                    //Cron.Minutely);
                    Cron.Monthly(5, 1, 0));    // El 5 de cada mes a la 1:00 a.m.
                break;

            case Enums.Enum.CategoriaIndicadorAutomatico.CPI_Servicios:
                RecurringJob.AddOrUpdate <IndicadorAutomaticoCPIServiciosStrategy>(
                    indicadorAutomatico.Nombre,
                    x => x.EjecutarIndicador(indicadorAutomatico.IndicadorViewModel),
                    //Cron.Minutely);
                    Cron.Monthly(5, 1, 15));    // El 5 de cada mes a la 1:15 a.m.
                break;

            case Enums.Enum.CategoriaIndicadorAutomatico.CPI_Llave_En_Mano:
                RecurringJob.AddOrUpdate <IndicadorAutomaticoCPILlaveManoStrategy>(
                    indicadorAutomatico.Nombre,
                    x => x.EjecutarIndicador(indicadorAutomatico.IndicadorViewModel),
                    //Cron.Minutely);
                    Cron.Monthly(5, 1, 30));    // El 5 de cada mes a la 1:30 a.m.
                break;
            }
        }
Пример #2
0
 public void DetenerJob(IndicadorAutomaticoViewModel indicadorAutomatico)
 {
     RecurringJob.RemoveIfExists(indicadorAutomatico.Nombre);
 }
Пример #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);
        }