Exemplo n.º 1
0
        public async Task <ActionResult> Deletepop(int id)
        {
            IndicadorsController     controlIndicador     = new IndicadorsController(db, userManager);
            ConfiguracionsController controlConfiguracion = new ConfiguracionsController(db, userManager);

            NotaIndicador nota = await db.NotaIndicador.FindAsync(id);

            Indicador indicador = await controlIndicador.getFromId(nota.Indicador.id);


            var userFull = await userManager.FindByEmailAsync(User.Identity.Name);

            var notasE = User.HasClaim(c => (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Nota.Editar" && c.Value == "1"));
            var super  = User.HasClaim(c => (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Super" && c.Value == "1"));



            ViewBag.editar        = controlConfiguracion.Editable(userFull.IDDependencia, indicador.Categoria, notasE, super);
            ViewBag.visible       = true;
            ViewBag.configuracion = await controlConfiguracion.Get();

            ViewBag.indicador = indicador;
            ViewBag.userFull  = userFull;


            return(View(nota));
        }
Exemplo n.º 2
0
        public async Task <ActionResult> DeleteConfirmedAsync(string Id)
        {
            string error = "";
            ConfiguracionsController controlConfiguracion = new ConfiguracionsController(db, userManager);

            var user = await userManager.FindByIdAsync(Id);

            try
            {
                var result = await userManager.DeleteAsync(user);

                if (!result.Succeeded)
                {
                    foreach (var errorA in result.Errors)
                    {
                        error += errorA.Description + "<br>";
                    }
                }
            }
            catch (Exception ex)
            {
                error = controlConfiguracion.SqlErrorHandler(ex);
            }
            HttpContext.Session.SetComplex("error", error);

            return(RedirectToAction("Index"));
        }
        public async Task <IActionResult> Delete(String id)
        {
            String error = "";

            var idInt   = Int32.Parse(id);
            var adjunto = await db.EjecucionAdjunto.FindAsync(idInt);

            if (adjunto != null)
            {
                ConfiguracionsController controlConfiguracion = new ConfiguracionsController(db, userManager);
                try
                {
                    var _path    = Path.Combine(_env.ContentRootPath, "wwwroot/UploadedFiles");
                    var filepath = Path.Combine(_path, adjunto.adjunto);
                    System.IO.File.Delete(filepath);

                    db.EjecucionAdjunto.Remove(adjunto);
                    await db.SaveChangesAsync();
                }
                catch (Exception ex)
                {
                    error = "Error: " + controlConfiguracion.SqlErrorHandler(ex);
                }
            }
            else
            {
                error = "Error: el adjunto no existe.";
            }

            return(Json(error));
        }
Exemplo n.º 4
0
        public async Task <ActionResult> DeleteConfirmed(string id)
        {
            string error = "";
            ConfiguracionsController controlConfiguracion = new ConfiguracionsController(db, userManager);

            ApplicationRole Rol = await db.Roles.FindAsync(id);

            try
            {
                var claims = await db.RoleClaims.Where(n => n.RoleId == Rol.Id).ToListAsync();

                db.RoleClaims.RemoveRange(claims);
                await db.SaveChangesAsync();

                db.Roles.Remove(Rol);
                await db.SaveChangesAsync();
            }
            catch (Exception ex)
            {
                error = controlConfiguracion.SqlErrorHandler(ex);
            }
            HttpContext.Session.SetComplex("error", error);

            return(RedirectToAction("Index"));
        }
Exemplo n.º 5
0
        public async Task <IActionResult> DetailsPop(int id, string tipo = "", string mensaje = "")
        {
            ConfiguracionsController configuracionControl = new ConfiguracionsController(db, userManager);
            EvaluacionsController    controlEvaluacion    = new EvaluacionsController(db);
            UnidadesdeMedida         Unidad = new UnidadesdeMedida();

            EjecucionCalculada respuestaFormato = new EjecucionCalculada();

            Ejecucion ejec = await db.Ejecucion.Where(n => n.id == id).FirstOrDefaultAsync();

            if (ejec != null)
            {
                //-------------------------------------------------------identificar si un usuario tiene acceso a editar una ejecucion



                if (User.HasClaim(c => (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Ejecucion.Editar" && c.Value == "1") ||
                                  (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Planeacion.Editar" && c.Value == "1")))
                {
                    ViewBag.MostrarBotonEditarEjecucion = await configuracionControl.PermisoMostrarEditarEjecucion(User, ejec);
                }
                else
                {
                    ViewBag.MostrarBotonEditarEjecucion = false;
                }
                //-------------------------------------------------------identificar si un usuario tiene acceso a editar una ejecucion


                EjecucionCalculada respuesta = new EjecucionCalculada();


                //-------------- generacion de un objeto genérico para manejar los diferentes tipos de indicadores
                ObjectHandle manejador       = Activator.CreateInstance(null, "seguimiento.Formulas." + ejec.Indicador.TipoIndicador.file); //se crea un manejador  op -objeto generico- y un operador generico que permite llamar a las formulas con la cadena del tipo de indiciador: mantenimiento, incremento etc
                Object       op              = manejador.Unwrap();
                Type         t               = op.GetType();
                MethodInfo   operadorPeriodo = t.GetMethod("Calculo_periodo"); //operador es un metodo generico que refleja la funcionalidad de Calculo periodo

                Periodo   periodoLineaBase = db.Periodo.Where(n => n.tipo == "lineabase").FirstOrDefault();
                Ejecucion lineaBase        = db.Ejecucion.Where(n => n.idperiodo == periodoLineaBase.id && n.idindicador == ejec.idindicador).FirstOrDefault();


                List <Evaluacion> evaluaciones = await controlEvaluacion.Get(ejec.idindicador, "Indicador");

                object[] args       = { ejec, null };                                                        //carga los argumentos en un objeto
                var      respuesta2 = (EjecucionCalculada)operadorPeriodo.Invoke(op, args);                  //envia los argumentos mediante invoke al metodo Calculo_periodo
                respuesta        = respuesta2;
                respuestaFormato = controlEvaluacion.SetEvaluacion(Unidad.Formato(respuesta), evaluaciones); //almacena cada ejecucionCalcuada en la lista pero antes ajusta el formato con la clase unidadess de medida


                ViewBag.Adjuntos = await db.EjecucionAdjunto.Where(n => n.idejecucion == ejec.id).ToListAsync();

                ViewBag.tipo    = tipo;
                ViewBag.mensaje = mensaje;
            }
            return(View(respuestaFormato));
        }
Exemplo n.º 6
0
        public async Task <ActionResult> Indicadorpop(int indicadorid = 0, string tipo = "", string mensaje = "")
        {
            IndicadorsController     controlIndicador     = new  IndicadorsController(db, userManager);
            ResponsablesController   controlResponsable   = new ResponsablesController(db, userManager);
            ConfiguracionsController controlConfiguracion = new ConfiguracionsController(db, userManager);

            int ID = Convert.ToInt32(indicadorid);

            Indicador indicador = await controlIndicador.getFromId(ID);


            if (User.Identity.Name != null)
            {
                var userFull = await userManager.FindByEmailAsync(User.Identity.Name);

                // obtiene las categorias
                var idsx = controlResponsable.GetAllIdsFromResponsable(userFull.IDDependencia);

                var notasE = User.HasClaim(c => (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Nota.Editar" && c.Value == "1"));
                var super  = User.HasClaim(c => (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Super" && c.Value == "1"));



                ViewBag.tipo          = tipo;
                ViewBag.mensaje       = mensaje;
                ViewBag.editar        = controlConfiguracion.Editable(userFull.IDDependencia, indicador.Categoria, notasE, super);
                ViewBag.visible       = true;
                ViewBag.configuracion = await controlConfiguracion.Get();

                ViewBag.indicador = indicador;
                ViewBag.userFull  = userFull;

                ViewBag.PermisoResponsable = idsx;
            }
            else
            {
                Configuracion config = await controlConfiguracion.Get();

                ViewBag.tipo    = tipo;
                ViewBag.mensaje = mensaje;


                ViewBag.editar             = false;
                ViewBag.userFull           = false;
                ViewBag.configuracion      = config;
                ViewBag.visible            = config.libre;
                ViewBag.PermisoResponsable = false;
            }


            var notas = await db.NotaIndicador.Include(n => n.Indicador).Include(n => n.User).Where(n => n.IdIndicador == ID).OrderByDescending(n => n.FechaCreacion).ToListAsync();

            return(View(notas.ToList()));
        }
        public async Task <ActionResult> DeleteConfirmed(int id)
        {
            string error = "";
            ConfiguracionsController controlConfiguracion = new ConfiguracionsController(db, userManager);
            Nivel nivel = await db.Nivel.FindAsync(id);

            try
            {
                db.Nivel.Remove(nivel);
                await db.SaveChangesAsync();
            }
            catch (Exception ex)
            {
                error = controlConfiguracion.SqlErrorHandler(ex);
                HttpContext.Session.SetComplex("error", error);
            }
            return(RedirectToAction("Index"));
        }
Exemplo n.º 8
0
        public async Task <ActionResult> Detailspop(int id)
        {
            CategoriasController     controlCategoria     = new CategoriasController(db, userManager);
            ConfiguracionsController controlConfiguracion = new ConfiguracionsController(db, userManager);


            Nota nota = await db.Nota.FindAsync(id);

            Categoria categoria = await controlCategoria.getFromId(nota.Categoria.id);


            if (User.Identity.Name != null)
            {
                var userFull = await userManager.FindByEmailAsync(User.Identity.Name);

                var notasE = User.HasClaim(c => (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Nota.Editar" && c.Value == "1"));
                var super  = User.HasClaim(c => (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Super" && c.Value == "1"));



                ViewBag.editar        = controlConfiguracion.Editable(userFull.IDDependencia, categoria, notasE, super);
                ViewBag.visible       = true;
                ViewBag.configuracion = await controlConfiguracion.Get();

                ViewBag.categoria = categoria;
                ViewBag.userFull  = userFull;
            }
            else
            {
                Configuracion config = await controlConfiguracion.Get();



                ViewBag.editar        = false;
                ViewBag.userFull      = false;
                ViewBag.configuracion = config;
                ViewBag.visible       = config.libre;
            }



            return(View(nota));
        }
Exemplo n.º 9
0
        public async Task <ActionResult> EditPop(int id)
        {
            ConfiguracionsController configuracionControl = new ConfiguracionsController(db, userManager);
            Ejecucion ejecucion = await db.Ejecucion.Where(n => n.id == id).FirstOrDefaultAsync();


            //-------------------------------------------------------identificar si un usuario tiene acceso a editar una ejecucion

            if (User.HasClaim(c => (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Ejecucion.Editar" && c.Value == "1") ||
                              (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Planeacion.Editar" && c.Value == "1")))
            {
                ViewBag.PuedeEditarEjecucion = await configuracionControl.PermisoEditarEjecucion(User, ejecucion);

                ViewBag.PuedeEditarPlaneado = await configuracionControl.PermisoEditarEjecucionPlaneado(User, ejecucion);
            }

            ViewBag.Adjuntos = await db.EjecucionAdjunto.Where(n => n.idejecucion == ejecucion.id).ToListAsync();

            return(View(ejecucion));
        }
        public async Task <bool> Evaluar()
        {
            ConfiguracionsController controlConfiguracion = new ConfiguracionsController(db, userManager);
            var configuracion = await controlConfiguracion.Get();

            if (configuracion.PonderacionTipo == "PonderacionRelativa")
            {
                //PonderacionRelativa ponderacion = new PonderacionRelativa();
                // var casa = ponderacion.Calculo_total_categoria(configuracion);
            }
            if (configuracion.PonderacionTipo == "PonderacionAbsoluta")
            {
                PonderacionAbsoluta ponderacion = new PonderacionAbsoluta(db, userManager);
                var casa = await ponderacion.Calculo_total_categoria(configuracion);
            }
            if (configuracion.PonderacionTipo == "PonderacionAbsolutaVacios")
            {
                PonderacionAbsolutaVacios ponderacion = new PonderacionAbsolutaVacios(db, userManager);
                var casa = await ponderacion.Calculo_total_categoria(configuracion);
            }

            return(true);
        }
Exemplo n.º 11
0
        public async Task <ActionResult> IndicadoresCategoria(String numero, String id, String periodo, string alto, string ancho, string titulo, string tipo)

        {
            ConfiguracionsController controlConfiguración = new ConfiguracionsController(db, userManager);

            Configuracion config = await controlConfiguración.Get();

            var    Numero      = Int32.Parse(numero);
            string IdCategoria = id;
            var    IdPeriodo   = Int32.Parse(periodo);



            ViewBag.id      = IdCategoria;
            ViewBag.Numero  = Numero;
            ViewBag.alto    = alto;
            ViewBag.ancho   = ancho;
            ViewBag.titulo  = titulo;
            ViewBag.periodo = periodo;
            ViewBag.tipo    = tipo;


            return(View("~/Views/Widget/IndicadoresCategoria.cshtml"));
        }
        public async Task <ActionResult> Resumen(int ID)
        {
            EjecucionCategoriaController controladorEjecuciones = new EjecucionCategoriaController(db, userManager);
            NotasController          controlnotas         = new NotasController(db, userManager);
            ConfiguracionsController controlconfigutacion = new ConfiguracionsController(db, userManager);
            Configuracion            config = await controlconfigutacion.Get();

            EvaluacionsController controlEvaluacion = new EvaluacionsController(db);


            List <Object>             respuesta        = new List <object>();
            List <EjecucionCategoria> listaEjecuciones = new List <EjecucionCategoria>();


            var categoria = await getFromId(ID);  //retoma la categoria por id desde la base de datos

            //if (categoria == null) { return new HttpStatusCodeResult(404, "no se encuentran categoria"); }  //error generado si no se encuentra la categoria

            if (config.PonderacionTipo == "PonderacionAbsoluta")
            {
                PonderacionAbsoluta pond = new PonderacionAbsoluta(db, userManager);
                categoria.Ponderador = await pond.CategoriaPonderador(ID);
            }

            int notasAbiertas = await controlnotas.NumeroNotasEstadoCategoriaId(ID, "Abierta");

            int notasCerradas = await controlnotas.NumeroNotasEstadoCategoriaId(ID, "Cerrada");

            ViewBag.notasAbiertas = notasAbiertas;
            ViewBag.notasCerradas = notasCerradas;

            listaEjecuciones = await controladorEjecuciones.GetFromCategoria(categoria.id);

            //======================================== obtiene los semanoforos===============================
            List <Evaluacion> evaluaciones = await controlEvaluacion.Get(categoria.id, "Categotia");

            var semaforos = controlEvaluacion.SetEvaluacionCategoria(listaEjecuciones, evaluaciones);

            //======================================== obtiene los semanoforos===============================
            object[] CategoriaConejecuciones = { categoria, listaEjecuciones, semaforos };
            respuesta.Add(CategoriaConejecuciones);


            ViewBag.categorias = respuesta;

            //-----------------------------Campos adicionales Inicio
            List <CampoValor> campos = new List <CampoValor>();
            var Campos = db.Campo.Where(m => m.NivelPadre.id == categoria.Nivel.id || m.TodaCategoria == true).ToList();

            foreach (Campo campon in Campos)
            {
                CampoValor cp = new CampoValor();
                cp.Campo = campon;
                cp.Valor = db.ValorCampo.Where(m => m.CampoPadre.Id == campon.Id && m.CategoriaPadre.id == categoria.id).FirstOrDefault();
                campos.Add(cp);
            }
            ViewBag.campos = campos;
            //-----------------------------Campos adicionales Fin

            return(View(respuesta));
        }
Exemplo n.º 13
0
        public async Task <ActionResult> CategoriaInfo(String numero, String id, String periodo, string alto, string ancho, string titulo, string tipo)

        {
            ConfiguracionsController controlConfiguración = new ConfiguracionsController(db, userManager);
            CategoriasController     controlCategoria     = new CategoriasController(db, userManager);
            IndicadorsController     controlIndicador     = new IndicadorsController(db, userManager);
            PeriodosController       controlPeriodo       = new PeriodosController(db, userManager);


            Configuracion config = await controlConfiguración.Get();

            var Numero      = Int32.Parse(numero);
            var IdCategoria = Int32.Parse(id);
            var IdPeriodo   = Int32.Parse(periodo);



            Categoria categoria = await controlCategoria.getFromId(IdCategoria);

            //hijos
            var hijos = await controlCategoria.getFromCategoria(categoria.id);

            if (hijos.Count > 0)
            {
                ViewBag.nombreHijos = hijos[0].Nivel.nombre;
                ViewBag.numeroHijos = hijos.Count;
            }



            //ponderador
            if (config.PonderacionTipo == "PonderacionAbsoluta")
            {
                PonderacionAbsoluta pond = new PonderacionAbsoluta(db, userManager);
                categoria.Ponderador = await pond.CategoriaPonderador(categoria.id); //80
            }

            //indicadores
            var indi = await controlIndicador.getFromCategoria(categoria.id);

            var indicadores = indi.Where(n => n.ponderador > 0);

            if (indicadores.Count() > 0)
            {
                ViewBag.numeroIndicadores = indicadores.Count();
            }
            else
            {
                ViewBag.numeroIndicadores = await controlCategoria.NumeroIndicadores(categoria.id); //81
            }

            //numero de indicadores en cada evaluacion del último periodo reportado
            if (IdPeriodo != 0)
            {
                // var LastPeriodoReport = COntrolPeriodos.UltimoPeriodoRepFromSubtotal(IdPeriodo);

                ViewBag.periodo = await controlPeriodo.GetFromId(IdPeriodo);

                var periodoSubtotal = await controlPeriodo.GetSubtotalFromPeriodo(IdPeriodo);

                if (periodoSubtotal > 0)
                {
                    ViewBag.periodoSubtotal = await db.Periodo.FindAsync(periodoSubtotal);
                }
            }



            ViewBag.Numero = Numero;
            ViewBag.alto   = alto;
            ViewBag.ancho  = ancho;
            ViewBag.titulo = titulo;
            //ViewBag.periodo = periodo;
            ViewBag.tipo = tipo;


            return(View(categoria));
        }