public Boolean ActualizarRequerimiento(sugerencia requerimientoNew)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {
                    sugerencia requerimientoOld = contexto.sugerencia.Find(requerimientoNew.ID);
                    /*sugerencia requerimientoOld = (from s in contexto.sugerencia
                                                   where s.ID == requerimientoNew.ID
                                                   select s).SingleOrDefault<sugerencia>();*/

                    if (requerimientoOld != null)
                    {
                        contexto.Entry(requerimientoOld).CurrentValues.SetValues(requerimientoNew);
                        //requerimientoOld = requerimientoNew;
                        contexto.SaveChanges();
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return false;
        }
        public List<proyecto> ObtenerProyectosDelUsuario(int usuarioId)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {
                    List<proyecto> listaProyectos = new List<proyecto>();

                    // Obtención de la lista de proyectos
                    listaProyectos = (from p in contexto.proyecto
                                      from pu in contexto.proyecto_usuario
                                      where pu.usuario_ID == usuarioId && pu.proyecto_ID == p.ID
                                      select p).ToList<proyecto>();
                    // Si la lista no está vacía se retorna
                    if (listaProyectos != null) { return listaProyectos; }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            // El usuario no tiene proyectos
            return null;
        }
 public List<causa_rechazo_sugerencia> ObtenerTodasCausaRechazoRequerimiento()
 {
     try
     {
         using (SagproEntities contexto = new SagproEntities())
         {
             List<causa_rechazo_sugerencia> listaCausaRechazoSugerencia = contexto.causa_rechazo_sugerencia.ToList<causa_rechazo_sugerencia>();
             if (listaCausaRechazoSugerencia != null) { return listaCausaRechazoSugerencia; }
         }
     }
     catch (Exception ex)
     {
         Debug.WriteLine(ex.ToString());
     }
     return null;
 }
 public int InsertarCausaRechazoRequerimiento(causa_rechazo_sugerencia causaRechazoRequerimiento)
 {
     try
     {
         using (SagproEntities contexto = new SagproEntities())
         {
             contexto.causa_rechazo_sugerencia.Add(causaRechazoRequerimiento);
             contexto.SaveChanges();
             return causaRechazoRequerimiento.ID;
         }
     }
     catch (Exception ex)
     {
         Debug.WriteLine(ex.ToString());
     }
     return 0;
 }
        public List<proyecto_usuario> ObtenerTodosProyectoUsuario()
        {
            try
            {
                using (SagproEntities contexto = new SagproEntities())
                {
                    List<proyecto_usuario> listaProyectoUsuario = contexto.proyecto_usuario.ToList<proyecto_usuario>();

                    return listaProyectoUsuario;
                }
            }
            catch(Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return null;
        }
        public List<prioridad_bug> ObtenerTodasPrioridadesDelBug()
        {
            try
            {
                using (SagproEntities context = new SagproEntities())
                {
                    List<prioridad_bug> listaPrioridadesBug = context.prioridad_bug.ToList<prioridad_bug>();

                    return listaPrioridadesBug;
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return null;
        }
        public List<tipo_nota> ObtenerTodasTiposDeNota()
        {
            try
            {
                using (SagproEntities contexto = new SagproEntities())
                {
                    List<tipo_nota> listaTiposNota = contexto.tipo_nota.ToList<tipo_nota>();

                    return listaTiposNota;
                }
            }
            catch(Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return null;
        }
        public List<esfuerzo_estimado> ObtenerTodosEsfuerzoEstimado()
        {
            try
            {
                using (SagproEntities contexto = new SagproEntities())
                {
                    List<esfuerzo_estimado> listaEsfuerzoEstimado = contexto.esfuerzo_estimado.ToList<esfuerzo_estimado>();

                    return listaEsfuerzoEstimado;
                }
            }
            catch(Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return null;
        }
 public Boolean InsertarHistorialRequerimiento(historial_sugerencia historialRequerimiento)
 {
     try
     {
         using (SagproEntities contexto = new SagproEntities())
         {
             contexto.historial_sugerencia.Add(historialRequerimiento);
             contexto.SaveChanges();
             return true;
         }
     }
     catch (Exception ex)
     {
         Debug.WriteLine(ex.ToString());
     }
     return false;
 }
        /// <summary>
        /// Obtiene los relacionamientos de los proyectos que tiene un usuario
        /// </summary>
        /// <param name="usuarioId">ID del usuario</param>
        public List<proyecto_usuario> ObtenerRelacionProyectosDelUsuario(int usuarioId)
        {
            try
            {
                using (SagproEntities contexto = new SagproEntities())
                {
                    List<proyecto_usuario> listaProyectosUsuario = contexto.proyecto_usuario.Where(pu => pu.usuario_ID == usuarioId).ToList<proyecto_usuario>();

                    // Obtenemos la lista de ID de proyectos en la que participa el usuario
                    return listaProyectosUsuario;
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return null;
        }
        public List<usuario> ObtenerTodosUsuario()
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {
                    // Obtención de todos usuarios
                    List<usuario> listaUsuario = contexto.usuario.ToList<usuario>();

                    return listaUsuario;
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            // No se encontró el usuario
            return null;
        }
 public Boolean EliminarCausaRechazoRequerimiento(int causaRechazoRequerimientoId)
 {
     try
     {
         using (SagproEntities contexto = new SagproEntities())
         {
             causa_rechazo_sugerencia causaRechazoRequerimientoEliminar = contexto.causa_rechazo_sugerencia.Find(causaRechazoRequerimientoId);
             if (causaRechazoRequerimientoEliminar != null)
             {
                 contexto.causa_rechazo_sugerencia.Remove(causaRechazoRequerimientoEliminar);
                 contexto.SaveChanges();
                 return true;
             }
         }
     }
     catch (Exception ex)
     {
         Debug.WriteLine(ex.ToString());
     }
     return false;
 }
        public Boolean EliminarComentarioBug(int comentarioBugId)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {
                    comentario_bug comentarioBugEliminar = contexto.comentario_bug.Find(comentarioBugId);

                    if (comentarioBugEliminar != null)
                    {
                        contexto.comentario_bug.Remove(comentarioBugEliminar);
                        contexto.SaveChanges();
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return false;
        }
        public Boolean ActualizarComentarioBug(comentario_bug comentarioBugNew)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {
                    comentario_bug comentarioBugOld = contexto.comentario_bug.Find(comentarioBugNew.ID);

                    if (comentarioBugOld != null)
                    {
                        contexto.Entry(comentarioBugOld).CurrentValues.SetValues(comentarioBugNew);
                        contexto.SaveChanges();
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return false;
        }
 public usuario ObtenerUsuarioPorLogin(String login)
 {
     try
     {
         // Obtenemos el contexto de la Base de Datos Sagpro
         using (SagproEntities contexto = new SagproEntities())
         {
             // Obtención de usuario mediante su login
             usuario usuarioDB = contexto.usuario.Where(u => u.login == login).SingleOrDefault<usuario>();
             /*usuario usuarioDB = (from u in contexto.usuario
                                  where u.login == login
                                  select u).SingleOrDefault<usuario>();*/
             // Si se encontró un usuario con su login correspondiente
             if (usuarioDB != null) { return usuarioDB; }
         }
     }
     catch (Exception ex)
     {
         Debug.WriteLine(ex.ToString());
     }
     // No se encontró el usuario
     return null;
 }
        public int InsertarTareaRequerimiento(tarea_sugerencia tareaRequerimiento)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {

                    // Se agrega la tarea del requerimiento a la tabla tarea_sugerencia
                    contexto.tarea_sugerencia.Add(tareaRequerimiento);
                    // Se efectúan los cambios en la base de datos
                    contexto.SaveChanges();
                    // Inserción correcta
                    return tareaRequerimiento.ID;
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            // No se pudo insertar
            return 0;
        }
        public Boolean EliminarTareaRequerimiento(int tareaRequerimientoId)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {
                    tarea_sugerencia tareaRequerimientoEliminar = contexto.tarea_sugerencia.Find(tareaRequerimientoId);

                    if (tareaRequerimientoEliminar != null)
                    {
                        contexto.tarea_sugerencia.Remove(tareaRequerimientoEliminar);
                        contexto.SaveChanges();
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return false;
        }
        public int InsertarComentarioBug(comentario_bug comentarioBug)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {

                    // Se agrega el comentario del bug a la tabla comentario_bug
                    contexto.comentario_bug.Add(comentarioBug);
                    // Se efectúan los cambios en la base de datos
                    contexto.SaveChanges();
                    // Inserción correcta
                    return comentarioBug.ID;
                }
            }
            catch(Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            // No se pudo insertar
            return 0;
        }
        public Boolean ValidarLogin(String login, String password)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {
                    // Obtención de usuario mediante su login y password
                    usuario usuarioDB = contexto.usuario.Where(u => u.login == login && u.password == password).SingleOrDefault<usuario>();
                    /*var usuarioDB = (from u in contexto.usuario
                                     where u.login == login && u.password == password
                                     select u).SingleOrDefault<usuario>();*/

                    // Si se encontró un Usuario con su login y password correspondiente
                    if (usuarioDB != null) { return true; }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine("ERROR:" + ex.ToString());
            }
            return false;
        }
        public Boolean ActualizarCausaRechazoRequerimiento(causa_rechazo_sugerencia causaRechazoRequerimientoNew)
        {
            try
            {
                using (SagproEntities contexto = new SagproEntities())
                {
                    causa_rechazo_sugerencia causaRechazoRequerimientoOld = contexto.causa_rechazo_sugerencia.Find(causaRechazoRequerimientoNew.ID);

                    if (causaRechazoRequerimientoOld != null)
                    {
                        contexto.Entry(causaRechazoRequerimientoOld).CurrentValues.SetValues(causaRechazoRequerimientoNew);
                        //causaRechazoRequerimientoOld = causaRechazoRequerimientoNew;
                        contexto.SaveChanges();
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return false;
        }
 public Boolean EliminarRequerimiento(int requerimientoId)
 {
     try
     {
         // Obtenemos el contexto de la Base de Datos Sagpro
         using (SagproEntities contexto = new SagproEntities())
         {
             // Búsqueda de requerimiento a eliminar
             sugerencia requerimientoEliminar = contexto.sugerencia.Find(requerimientoId);
             if (requerimientoEliminar != null)
             {
                 contexto.sugerencia.Remove(requerimientoEliminar);
                 contexto.SaveChanges();
                 return true;
             }
         }
     }
     catch (Exception ex)
     {
         Debug.WriteLine(ex.ToString());
     }
     // Si no se encontró el usuario o hubo un error en la eliminación
     return false;
 }
        public Boolean ActualizarTareaRequerimiento(tarea_sugerencia tareaRequerimientoNew)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {
                    tarea_sugerencia tareaRequerimientoOld = contexto.tarea_sugerencia.Find(tareaRequerimientoNew.ID);

                    if (tareaRequerimientoOld != null)
                    {
                        contexto.Entry(tareaRequerimientoOld).CurrentValues.SetValues(tareaRequerimientoNew);
                        //tareaRequerimientoOld = tareaRequerimientoNew;
                        contexto.SaveChanges();
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            return false;
        }
        public List<comentario_sugerencia> ObtenerComentariosDelRequerimiento(int requerimientoId)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {

                    // Obtención de la lista de comentarios del requerimiento
                    List<comentario_sugerencia> listaComentariosRequerimiento = contexto.comentario_sugerencia.Where(cs => cs.sugerencia_ID == requerimientoId).ToList<comentario_sugerencia>();

                    // Verificación de existencia de comentarios del requerimiento
                    if (listaComentariosRequerimiento != null) { return listaComentariosRequerimiento; }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            // Si no existen comentarios del requerimiento
            return null;
        }
        public List<sugerencia> ObtenerRequerimientosDelUsuarioImplementador(int usuarioId)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {

                    // Obtención de la lista de requerimientos del usuario (implementador)
                    List<sugerencia> listaRequerimientos = contexto.sugerencia.Where(s => s.usuario_implementador_FK == usuarioId).ToList<sugerencia>();

                    // Verificación de existencia de requerimientos
                    if (listaRequerimientos != null) { return listaRequerimientos; }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            // Si no existen requerimientos
            return null;
        }
        public List<sugerencia> ObtenerRequerimientosDelProyecto(int proyectoId)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {

                    // Obtención de la lista de requerimientos
                    List<sugerencia> listaRequerimientos = contexto.sugerencia.Where(s => s.proyecto_ID == proyectoId).ToList<sugerencia>();
                    /*List<sugerencia> listaRequerimientos = (from s in contexto.sugerencia
                                                            where s.proyecto_ID == proyectoId
                                                            select s).ToList<sugerencia>();*/

                    // Verificación de existencia de requerimientos
                    if (listaRequerimientos != null) { return listaRequerimientos; }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            // Si no existen requerimientos
            return null;
        }
        public List<comentario_bug> ObtenerComentariosDelBug(int bugId)
        {
            try
            {
                // Obtenemos el contexto de la Base de Datos Sagpro
                using (SagproEntities contexto = new SagproEntities())
                {

                    // Obtención de la lista de comentarios del bug
                    List<comentario_bug> listaComentariosBug = contexto.comentario_bug.Where(cb => cb.bug_ID == bugId).ToList<comentario_bug>();

                    // Verificación de existencia de comentarios del bug
                    if (listaComentariosBug != null) { return listaComentariosBug; }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            // Si no existen comentarios del bug
            return null;
        }