Example #1
0
        public async Task <ActionResult> AddOperation([Bind(Include = "idOperation,Nombre,Descripcion,Type ,idPredecesora, Validable, OperationClass, IteracionesPermitidas, PorcentajeAceptacion")] Operation operation)
        {
            Process proc = (Process)TempData["Proceso"];

            if (proc == null)
            {
                return(HttpNotFound());
            }
            if (ModelState.IsValid)
            {
                if (operation.IteracionesPermitidas >= 0)
                {
                    Process process = db.Process.Find(proc.idProcess);
                    process.Operations.Add(operation);
                    ViewBag.Proceso = process.Criterio;
                    await db.SaveChangesAsync();

                    ViewBag.idPredecesora = new SelectList(process.Operations.ToList(), "idOperation", "Nombre");
                    return(PartialView("_AddOperation"));
                }
            }
            TempData["Proceso"]   = proc;
            ViewBag.Proceso       = proc.Criterio;
            ViewBag.idPredecesora = new SelectList(proc.Operations.ToList(), "idOperation", "Nombre");
            return(PartialView("_AddOperation"));
        }
Example #2
0
        public async Task <JsonResult> AddFunctionary(string rut, string cargo)
        {
            Entities entidad = (Entities)TempData["Entity"];
            Entities entity  = await db.Entity.FindAsync(entidad.idEntities);

            if (entity == null)
            {
                return(Json(new { sucess = false, reload = true }, JsonRequestBehavior.AllowGet));
            }
            Functionary functionary = db.Functionary.Where(f => f.Rut.Equals(rut)).FirstOrDefault();
            Functionary funcionario = entity.Involucrados.Where(fu => fu.Rut.Equals(rut)).FirstOrDefault();

            if (functionary == null || funcionario != null)
            {
                TempData["Entity"] = entity;
                return(Json(new { sucess = false }, JsonRequestBehavior.AllowGet));
            }
            string            carrera = functionary.idCareer == null ? " " : functionary.Carrera.Nombre;
            FunctionaryEntity fe      = new FunctionaryEntity {
                idEntities = entity.idEntities, idUser = functionary.idUser, Cargo = cargo
            };

            entity.FuncionarioEntidad.Add(fe);
            entity.Involucrados.Add(functionary);
            functionary.Entidades.Add(entity);
            functionary.FuncionarioEntidad.Add(fe);
            await db.SaveChangesAsync();

            TempData["Entity"] = entity;
            return(Json(new { iduser = functionary.idUser, nombre = functionary.Nombre, apellido = functionary.Apellido, carrera = carrera, sucess = true }, JsonRequestBehavior.AllowGet));
        }
Example #3
0
        public async Task <ActionResult> AddPermission(Guid?id)
        {
            Role rol  = (Role)TempData["Role"];
            Role role = await db.Role.FindAsync(rol.idRole);

            if (role == null)
            {
                return(Json(new { sucess = false, JsonRequestBehavior.AllowGet }));
            }
            Permission permission = await db.Permission.FindAsync(id);

            if (!role.Permisos.Contains(permission))
            {
                role.Permisos.Add(permission);
                await db.SaveChangesAsync();

                TempData["Role"] = role;
                return(Json(new { idpermission = permission.idPermission, textlink = permission.TextLink, controller = permission.Controller, actionresult = permission.ActionResult, sucess = true }, JsonRequestBehavior.AllowGet));
            }
            return(Json(new { sucess = false }, JsonRequestBehavior.AllowGet));
        }
Example #4
0
        public async Task <ActionResult> ResetPass(User usuario)
        {
            User user = (User)TempData["account"];

            using (SMGPAContext db = new SMGPAContext())
            {
                db.Configuration.ValidateOnSaveEnabled = false;
                User u = await db.User.FindAsync(user.idUser);

                u.Contrasena = mdencoder.EncodePasswordMd5(usuario.Contrasena);
                db.User.Attach(u);
                db.Entry(u).Property(x => x.Contrasena).IsModified = true;
                await db.SaveChangesAsync();

                ViewBag.MensajeRestablecido = "Contraseña restablecida";
                return(View());
            }
        }
Example #5
0
        public async Task <ActionResult> ConfigureTask([Bind(Include = "idTask,fechaInicio,fechaFin,TiempoInactividad,DesplazamientoHoras,DesplazamientoDias, Estado, idFunctionary, idResponsable, idEntities, idOperation")] Tasks task)
        {
            Activity activity   = (Activity)TempData["Activity"];
            DateTime?higherdate = null;
            DateTime?lowerdate  = null;
            Activity actividad  = db.Activity.Find(activity.idActivity);
            Tasks    Tarea      = (Tasks)TempData["Task"];

            if (ModelState.IsValid)
            {
                Tasks tarea = await db.Task.SingleAsync(t => t.idTask.Equals(Tarea.idTask));

                if (tarea == null)
                {
                    return(HttpNotFound());
                }
                Operation operacion = await db.Operation.FindAsync(tarea.idOperation);

                switch (operacion.Type)
                {
                case OperationType.ENTIDAD:
                    if (task.idResponsable != null)
                    {
                        tarea.ResponsableEntity = await db.Entity.FindAsync(task.idResponsable);
                    }
                    else
                    {
                        TempData["Task"]      = tarea;
                        ViewBag.idFunctionary = new SelectList(db.Functionary.ToList(), "idUser", "Nombre");
                        ViewBag.idEntities    = new SelectList(db.Entity.ToList(), "idEntities", "Nombre");
                        ViewBag.idResponsable = new SelectList(db.Entity.ToList(), "idEntities", "Nombre");
                        ViewBag.Creada        = null;
                        ViewBag.Errores       = "Tarea con Errores, debe especificar a la Entidad responsable";
                        TempData["Activity"]  = db.Activity.Find(activity.idActivity);
                        return(PartialView("_ConfigureTask", await db.Task.FindAsync(Tarea.idTask)));
                    }
                    break;

                case OperationType.FUNCIONARIO:
                    if (task.idFunctionary != null)
                    {
                        tarea.Responsable = await db.Functionary.FindAsync(task.idFunctionary);
                    }
                    else
                    {
                        TempData["Task"]      = tarea;
                        ViewBag.idFunctionary = new SelectList(db.Functionary.ToList(), "idUser", "Nombre");
                        ViewBag.idEntities    = new SelectList(db.Entity.ToList(), "idEntities", "Nombre");
                        ViewBag.Creada        = null;
                        ViewBag.Errores       = "Tarea con Errores, debe especificar al funcionario Responsable";
                        TempData["Activity"]  = db.Activity.Find(activity.idActivity);
                        return(PartialView("_ConfigureTask", await db.Task.FindAsync(Tarea.idTask)));
                    }
                    break;
                }
                if (operacion.Validable)
                {
                    if (task.idEntities != null)
                    {
                        tarea.Participantes = await db.Entity.FindAsync(task.idEntities);
                    }
                    else
                    {
                        TempData["Task"]      = tarea;
                        ViewBag.idFunctionary = new SelectList(db.Functionary.ToList(), "idUser", "Nombre");
                        ViewBag.idResponsable = new SelectList(db.Entity.ToList(), "idEntities", "Nombre");
                        ViewBag.idEntities    = new SelectList(db.Entity.ToList(), "idEntities", "Nombre");
                        ViewBag.Creada        = null;
                        ViewBag.Errores       = "Tarea con Errores, debe especificar a la Entidad validadora";
                        TempData["Activity"]  = db.Activity.Find(activity.idActivity);
                        return(PartialView("_ConfigureTask", await db.Task.FindAsync(Tarea.idTask)));
                    }
                }
                tarea.fechaInicio = task.fechaInicio;
                tarea.fechaFin    = task.fechaFin;
                tarea.Estado      = StatusEnum.INACTIVA;
                if (tarea.fechaInicio != null && tarea.fechaFin != null && tarea.fechaInicio > DateTime.Now &&
                    tarea.fechaFin > tarea.fechaInicio)
                {
                    foreach (Tasks t in actividad.Tareas)
                    {
                        if (t.fechaInicio < lowerdate || lowerdate == null)
                        {
                            lowerdate = t.fechaInicio;
                        }
                        if (t.fechaFin > higherdate || higherdate == null)
                        {
                            higherdate = t.fechaFin;
                        }
                    }
                    actividad.start_date = ((DateTime)lowerdate).Date;
                    actividad.end_date   = ((DateTime)higherdate).Date;
                    await db.SaveChangesAsync();

                    TempData["Task"]      = tarea;
                    ViewBag.Creada        = "Tarea ha sido configurada correctamente";
                    ViewBag.Errores       = null;
                    ViewBag.idResponsable = new SelectList(db.Entity.ToList(), "idEntities", "Nombre");
                    ViewBag.idFunctionary = new SelectList(db.Functionary.ToList(), "idUser", "Nombre");
                    ViewBag.idEntities    = new SelectList(db.Entity.ToList(), "idEntities", "Nombre");
                    return(PartialView("_ConfigureTask", tarea));
                }
            }
            TempData["Task"] = await db.Task.FindAsync(Tarea.idTask);

            ViewBag.idResponsable = new SelectList(db.Entity.ToList(), "idEntities", "Nombre");
            ViewBag.idFunctionary = new SelectList(db.Functionary.ToList(), "idUser", "Nombre");
            ViewBag.idEntities    = new SelectList(db.Entity.ToList(), "idEntities", "Nombre");
            ViewBag.Creada        = null;
            ViewBag.Errores       = "Tarea con Errores, considerar que Fecha de Inicio debe ser mayor al tiempo actual";
            TempData["Activity"]  = db.Activity.Find(activity.idActivity);
            return(PartialView("_ConfigureTask", await db.Task.FindAsync(Tarea.idTask)));
        }
Example #6
0
        public async Task <ActionResult> AddObservation([Bind(Include = "idObservation,FechaComentario,Comentario,ValidacionEstatus")] Observation observation)
        {
            Tasks Task  = (Tasks)TempData["Task"];
            Tasks Tarea = await db.Task.FindAsync(Task.idTask);

            Functionary user = await db.Functionary.FindAsync((Guid)Session["UserID"]);

            string       link        = HttpContext.Request.Url.Scheme + "://" + HttpContext.Request.Url.Authority + Url.Action("Details", "Tasks", new { id = Tarea.idTask });
            Notification notificator = new Notification();

            if (ModelState.IsValid)
            {
                observation.idObservation   = Guid.NewGuid();
                observation.FechaComentario = DateTime.Now;
                observation.Funcionario     = user;
                Tarea.Observaciones.Add(observation);
                user.Observaciones.Add(observation);
                Tarea.Estado = StatusEnum.EN_PROGRESO;
                List <Guid>        idsUsuario = new List <Guid>();
                List <Observation> Obs        = Tarea.Observaciones.ToList();
                //obtengo todas las observaciones aceptadas de tarea
                foreach (Observation o in Obs)
                {
                    if (!idsUsuario.Contains(o.Funcionario.idUser) && o.ValidacionEstatus == Validate.APROBADO)
                    {
                        idsUsuario.Add(o.Funcionario.idUser);
                    }
                }
                //se debe validar que todos los Funcionarios de la Entidad tengan observaciones sobre la Tarea
                switch (Tarea.Operacion.Type)
                {
                case OperationType.ENTIDAD:
                    bool EntidadParticipo   = false;
                    bool EntidadResponsable = false;
                    if (Tarea.Operacion.Validable)
                    {
                        foreach (Functionary f in Tarea.Participantes.Involucrados)
                        {
                            await notificator.NotificateAll(user, db.Functionary.Find(f.idUser), Tarea, link, 3);

                            Notificacion n = new Notificacion();
                            n.idNotification = Guid.NewGuid();
                            n.Fecha          = DateTime.Now;
                            n.Funcionario    = f;
                            n.Cuerpo         = "El Funcionario " + user.Nombre + " " + user.Apellido + " ha comentado la Tarea: " + Tarea.Operacion.Nombre;
                            n.UrlAction      = link;
                            n.Vista          = false;
                            f.Notificaciones.Add(n);
                        }
                        int    divisor1   = idsUsuario.Count;
                        int    dividendo1 = Tarea.Participantes.Involucrados.Count + Tarea.ResponsableEntity.Involucrados.Count;
                        double division1  = (double)divisor1 / dividendo1;
                        double resultado1 = division1 * 100.0;
                        //verificamos que al menos el 50% de los involucrados haya comentado
                        if (resultado1 >= Tarea.Operacion.PorcentajeAceptacion)
                        {
                            EntidadParticipo = true;
                        }
                        foreach (Functionary f in Tarea.ResponsableEntity.Involucrados)
                        {
                            await notificator.NotificateAll(user, db.Functionary.Find(f.idUser), Tarea, link, 3);

                            Notificacion n = new Notificacion();
                            n.idNotification = Guid.NewGuid();
                            n.Fecha          = DateTime.Now;
                            n.Funcionario    = f;
                            n.Cuerpo         = "El Funcionario " + user.Nombre + " " + user.Apellido + " ha comentado la Tarea: " + Tarea.Operacion.Nombre;
                            n.UrlAction      = link;
                            n.Vista          = false;
                            f.Notificaciones.Add(n);
                        }
                        int    divisor2   = idsUsuario.Count;
                        int    dividendo2 = Tarea.ResponsableEntity.Involucrados.Count + Tarea.Participantes.Involucrados.Count;
                        double division2  = (double)divisor2 / dividendo2;
                        double resultado2 = division2 * 100.0;
                        if (resultado2 >= Tarea.Operacion.PorcentajeAceptacion)
                        {
                            EntidadResponsable = true;
                        }
                        if (EntidadParticipo && EntidadResponsable)
                        {
                            Tarea.Estado = StatusEnum.COMPLETADA;
                        }
                    }
                    else
                    {
                        foreach (Functionary f in Tarea.ResponsableEntity.Involucrados)
                        {
                            await notificator.NotificateAll(user, db.Functionary.Find(f.idUser), Tarea, link, 3);

                            Notificacion n = new Notificacion();
                            n.idNotification = Guid.NewGuid();
                            n.Fecha          = DateTime.Now;
                            n.Funcionario    = f;
                            n.Cuerpo         = "El Funcionario " + user.Nombre + " " + user.Apellido + " ha comentado la Tarea: " + Tarea.Operacion.Nombre;
                            n.UrlAction      = link;
                            n.Vista          = false;
                            f.Notificaciones.Add(n);
                        }
                        int    divisor2   = idsUsuario.Count;
                        int    dividendo2 = Tarea.ResponsableEntity.Involucrados.Count;
                        double division2  = (double)divisor2 / dividendo2;
                        double resultado2 = division2 * 100.0;
                        if (resultado2 >= Tarea.Operacion.PorcentajeAceptacion)
                        {
                            EntidadResponsable = true;
                        }
                        if (EntidadResponsable)
                        {
                            Tarea.Estado = StatusEnum.COMPLETADA;
                        }
                    }

                    break;

                case OperationType.FUNCIONARIO:
                    bool Entidad = false;
                    if (Tarea.Operacion.Validable)
                    {
                        foreach (Functionary f in Tarea.Participantes.Involucrados)
                        {
                            await notificator.NotificateAll(user, db.Functionary.Find(f.idUser), Tarea, link, 3);

                            Notificacion n = new Notificacion();
                            n.idNotification = Guid.NewGuid();
                            n.Fecha          = DateTime.Now;
                            n.Funcionario    = f;
                            n.Cuerpo         = "El Funcionario " + user.Nombre + " " + user.Apellido + " ha comentado la Tarea: " + Tarea.Operacion.Nombre;
                            n.UrlAction      = link;
                            n.Vista          = false;
                            f.Notificaciones.Add(n);
                        }
                        int    divisor1   = idsUsuario.Count;
                        int    dividendo1 = Tarea.Participantes.Involucrados.Count;
                        double division1  = (double)divisor1 / dividendo1;
                        double resultado1 = division1 * 100.0;
                        //verificamos que al menos el 50% de los involucrados haya comentado
                        if (resultado1 >= Tarea.Operacion.PorcentajeAceptacion)
                        {
                            Entidad = true;
                        }
                        //verificamos que al menos el 50% de los involucrados haya comentado
                        if (Entidad)
                        {
                            Tarea.Estado = StatusEnum.COMPLETADA;
                        }
                    }
                    break;
                }
                await db.SaveChangesAsync();

                return(PartialView());
            }
            return(PartialView());
        }