u/bodqhrohro/swineboard Commit - r210:952de927

Added ban middleware. Now banned user's won't cause load to the server.

neko259 -

r210:952de927 default

parent child

boards/middlewares.py

0 created 644 +17 0

@@ -0,0 +1,17 b''
	1	from django.shortcuts import redirect
	2	from boards import views, utils
	3	from boards.models import Ban
	4
	5
	6	class BanMiddleware:
	7	"""This is run before showing the thread. Banned users don't need to see
	8	anything"""
	9
	10	def process_view(self, request, view_func, view_args, view_kwargs):
	11
	12	if view_func != views.you_are_banned:
	13	ip = utils.get_client_ip(request)
	14	is_banned = Ban.objects.filter(ip=ip).exists()
	15
	16	if is_banned:
	17	return redirect(views.you_are_banned) No newline at end of file

boards/templates/boards/base.html

0 +1 -1

             {% load staticfiles %}
             {% load i18n %}
             <!DOCTYPE html>
             <html>
             <head>
                 <link rel="stylesheet" type="text/css"
                       href="{{ STATIC_URL }}css/jquery.fancybox.css" media="all"/>
                 <link rel="stylesheet" type="text/css"
-                      href="{{ STATIC_URL }}css/{{ theme }}/base_page.css?3" media="all"/>
+                      href="{{ STATIC_URL }}css/{{ theme }}/base_page.css?4" media="all"/>
                 <link rel="alternate" type="application/rss+xml" href="rss/" title="
                 {% trans 'Feed' %}"/>
                 <link rel="icon" type="image/png"
                       href="{{ STATIC_URL }}favicon.png">
                 <meta name="viewport" content="width=device-width, initial-scale=1"/>
                 <meta charset="utf-8"/>
                 {% block head %}{% endblock %}
             </head>
             <body>
             <script src="{{ STATIC_URL }}js/jquery-2.0.1.min.js"></script>
             <script src="{{ STATIC_URL }}js/jquery.fancybox.pack.js"></script>
             <script src="{% url 'django.views.i18n.javascript_catalog' %}"></script>
             <script src="{{ STATIC_URL }}js/refmaps.js"></script>
             <script src="{{ STATIC_URL }}js/main.js"></script>
             <div class="navigation_panel">
                 <a class="link" href="{% url 'index' %}">{% trans "All threads" %}</a>
                 {% for tag in tags %}
                     <a class="tag" href="{% url 'tag' tag_name=tag.name %}"
                             >{{ tag.name }}</a>
                 {% endfor %}
                 <a class="tag" href="{% url 'tags' %}" alt="{% trans 'Tag management' %}"
                         >[...]</a>
                 <a class="link" href="{% url 'settings' %}">{% trans 'Settings' %}</a>
             </div>
             {% block content %}{% endblock %}
             <div class="navigation_panel">
                 {% block metapanel %}{% endblock %}
                 [<a href="{% url "login" %}">{% trans 'Login' %}</a>]
                 <a class="link" href="#top">{% trans 'Up' %}</a>
             </div>
             <div class="footer">
                 <!-- Put your banners here -->
             </div>
             </body>
             </html>

boards/templates/boards/settings.html

0 +1 -1

             {% extends "boards/base.html" %}
             {% load i18n %}
             {% block head %}
                 <title>Neboard settings</title>
             {% endblock %}
             {% block content %}
                 <div class="post">
                 <p>
                     {% trans 'User:' %} <b>{{ user.user_id }}</b>.
                     {% if user.is_moderator %}
                         {% trans 'You are moderator.' %}
                     {% endif %}
                 </p>
                 <p>{% trans 'Posts:' %} {{ user.get_post_count }}</p>
                 <p>{% trans 'First access:' %} {{ user.registration_time }}</p>
                 {% if user.get_last_access_time %}
                     <p>{% trans 'Last access:' %} {{ user.get_last_access_time }}</p>
                 {% endif %}
                 </div>
                 <div class="post-form-w">
                 <div class="post-form">
                     <form method="post">{% csrf_token %}
                         {{ form.as_p }}
                     <hr />
+                    <input type="submit" value="{% trans "Save" %}" />
                     </form>
                 </div>
-                <input type="submit" value="{% trans "Save" %}" />
                 </div>
             {% endblock %}

boards/utils.py

0 +9 0

             """
             This module contains helper functions and helper classes.
             """
             from neboard import settings
             import time
             KEY_CAPTCHA_FAILS = 'key_captcha_fails'
             KEY_CAPTCHA_DELAY_TIME = 'key_captcha_delay_time'
             KEY_CAPTCHA_LAST_ACTIVITY = 'key_captcha_last_activity'
             def need_include_captcha(request):
                 """
                 Check if request is made by a user.
                 It contains rules which check for bots.
                 """
                 if not settings.ENABLE_CAPTCHA:
                     return False
                 enable_captcha = False
                 #newcomer
                 if KEY_CAPTCHA_LAST_ACTIVITY not in request.session:
                     return settings.ENABLE_CAPTCHA
                 last_activity = request.session[KEY_CAPTCHA_LAST_ACTIVITY]
                 current_delay = int(time.time()) - last_activity
                 delay_time = (request.session[KEY_CAPTCHA_DELAY_TIME]
                               if KEY_CAPTCHA_DELAY_TIME in request.session
                               else settings.CAPTCHA_DEFAULT_SAFE_TIME)
                 if current_delay < delay_time:
                     enable_captcha = True
                 print 'ENABLING' + str(enable_captcha)
                 return enable_captcha
             def update_captcha_access(request, passed):
                 """
                 Update captcha fields.
                 It will reduce delay time if user passed captcha verification and
                 it will increase it otherwise.
                 """
                 session = request.session
                 delay_time = (request.session[KEY_CAPTCHA_DELAY_TIME]
                               if KEY_CAPTCHA_DELAY_TIME in request.session
                               else settings.CAPTCHA_DEFAULT_SAFE_TIME)
                 print "DELAY TIME = " + str(delay_time)
                 if passed:
                     delay_time -= 2 if delay_time >= 7 else 5
                 else:
                     delay_time += 10
                 session[KEY_CAPTCHA_LAST_ACTIVITY] = int(time.time())
                 session[KEY_CAPTCHA_DELAY_TIME] = delay_time
+            def get_client_ip(request):
+                x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
+                if x_forwarded_for:
+                    ip = x_forwarded_for.split(',')[-1].strip()
+                else:
+                    ip = request.META.get('REMOTE_ADDR')
+                return ip
  No newline at end of file

boards/views.py

0 +3 -11

             import hashlib
             import string
             from django.core.urlresolvers import reverse
             from django.http import HttpResponseRedirect
             from django.template import RequestContext
             from django.shortcuts import render, redirect, get_object_or_404
             from django.utils import timezone
             from boards import forms
             import boards
             from boards import utils
             from boards.forms import ThreadForm, PostForm, SettingsForm, PlainErrorList, \
                 ThreadCaptchaForm, PostCaptchaForm, LoginForm, ModeratorSettingsForm
             from boards.models import Post, Tag, Ban, User, RANK_USER, SETTING_MODERATE
             from boards import authors
+            from boards.utils import get_client_ip
             import neboard
             def index(request, page=0):
                 context = _init_default_context(request)
                 if utils.need_include_captcha(request):
                     threadFormClass = ThreadCaptchaForm
                     kwargs = {'request': request}
                 else:
                     threadFormClass = ThreadForm
                     kwargs = {}
                 if request.method == 'POST':
                     form = threadFormClass(request.POST, request.FILES,
                                            error_class=PlainErrorList, **kwargs)
                     form.session = request.session
                     if form.is_valid():
                         return _new_post(request, form)
                 else:
                     form = threadFormClass(error_class=PlainErrorList, **kwargs)
                 threads = []
                 for thread in Post.objects.get_threads(page=int(page)):
                     threads.append({'thread': thread,
                                     'bumpable': thread.can_bump()})
                 context['threads'] = None if len(threads) == 0 else threads
                 context['form'] = form
                 context['pages'] = range(Post.objects.get_thread_page_count())
                 return render(request, 'boards/posting_general.html',
                               context)
             def _new_post(request, form, thread_id=boards.models.NO_PARENT):
                 """Add a new post (in thread or as a reply)."""
-                ip = _get_client_ip(request)
+                ip = get_client_ip(request)
-                is_banned = Ban.objects.filter(ip=ip).count() > 0
+                is_banned = Ban.objects.filter(ip=ip).exists()
                 if is_banned:
                     return redirect(you_are_banned)
                 data = form.cleaned_data
                 title = data['title']
                 text = data['text']
                 if 'image' in data.keys():
                     image = data['image']
                 else:
                     image = None
                 tags = []
                 new_thread = thread_id == boards.models.NO_PARENT
                 if new_thread:
                     tag_strings = data['tags']
                     if tag_strings:
                         tag_strings = tag_strings.split(' ')
                         for tag_name in tag_strings:
                             tag_name = string.lower(tag_name.strip())
                             if len(tag_name) > 0:
                                 tag, created = Tag.objects.get_or_create(name=tag_name)
                                 tags.append(tag)
                 op = None if thread_id == boards.models.NO_PARENT else \
                     get_object_or_404(Post, id=thread_id)
                 post = Post.objects.create_post(title=title, text=text, ip=ip,
                                                 thread=op, image=image,
                                                 tags=tags, user=_get_user(request))
                 thread_to_show = (post.id if new_thread else thread_id)
                 if new_thread:
                     return redirect(thread, post_id=thread_to_show)
                 else:
                     return redirect(reverse(thread, kwargs={'post_id': thread_to_show}) +
                                     '#' + str(post.id))
             def tag(request, tag_name, page=0):
                 """Get all tag threads (posts without a parent)."""
                 tag = get_object_or_404(Tag, name=tag_name)
                 threads = []
                 for thread in Post.objects.get_threads(tag=tag, page=int(page)):
                     threads.append({'thread': thread,
                                     'bumpable': thread.can_bump()})
                 if request.method == 'POST':
                     form = ThreadForm(request.POST, request.FILES,
                                       error_class=PlainErrorList)
                     if form.is_valid():
                         return _new_post(request, form)
                 else:
                     form = forms.ThreadForm(initial={'tags': tag_name},
                                             error_class=PlainErrorList)
                 context = _init_default_context(request)
                 context['threads'] = None if len(threads) == 0 else threads
                 context['tag'] = tag
                 context['pages'] = range(Post.objects.get_thread_page_count(tag=tag))
                 context['form'] = form
                 return render(request, 'boards/posting_general.html',
                               context)
             def thread(request, post_id):
                 """Get all thread posts"""
                 if utils.need_include_captcha(request):
                     postFormClass = PostCaptchaForm
                     kwargs = {'request': request}
                 else:
                     postFormClass = PostForm
                     kwargs = {}
                 if request.method == 'POST':
                     form = postFormClass(request.POST, request.FILES,
                                          error_class=PlainErrorList, **kwargs)
                     form.session = request.session
                     if form.is_valid():
                         return _new_post(request, form, post_id)
                 else:
                     form = postFormClass(error_class=PlainErrorList, **kwargs)
                 posts = Post.objects.get_thread(post_id)
                 context = _init_default_context(request)
                 context['posts'] = posts
                 context['form'] = form
                 context['bumpable'] = posts[0].can_bump()
                 return render(request, 'boards/thread.html', context)
             def login(request):
                 """Log in with user id"""
                 context = _init_default_context(request)
                 if request.method == 'POST':
                     form = LoginForm(request.POST, request.FILES,
                                      error_class=PlainErrorList)
                     if form.is_valid():
                         user = User.objects.get(user_id=form.cleaned_data['user_id'])
                         request.session['user_id'] = user.id
                         return redirect(index)
                 else:
                     form = LoginForm()
                 context['form'] = form
                 return render(request, 'boards/login.html', context)
             def settings(request):
                 """User's settings"""
                 context = _init_default_context(request)
                 user = _get_user(request)
                 is_moderator = user.is_moderator()
                 if request.method == 'POST':
                     if is_moderator:
                         form = ModeratorSettingsForm(request.POST,
                                                       error_class=PlainErrorList)
                     else:
                         form = SettingsForm(request.POST, error_class=PlainErrorList)
                     if form.is_valid():
                         selected_theme = form.cleaned_data['theme']
                         user.save_setting('theme', selected_theme)
                         if is_moderator:
                             moderate = form.cleaned_data['moderate']
                             user.save_setting(SETTING_MODERATE, moderate)
                         return redirect(settings)
                 else:
                     selected_theme = _get_theme(request)
                     if is_moderator:
                         form = ModeratorSettingsForm(initial={'theme': selected_theme,
                                                      'moderate': context['moderator']},
                                             error_class=PlainErrorList)
                     else:
                         form = SettingsForm(initial={'theme': selected_theme},
                                             error_class=PlainErrorList)
                 context['form'] = form
                 return render(request, 'boards/settings.html', context)
             def all_tags(request):
                 """All tags list"""
                 context = _init_default_context(request)
                 context['all_tags'] = Tag.objects.get_not_empty_tags()
                 return render(request, 'boards/tags.html', context)
             def jump_to_post(request, post_id):
                 """Determine thread in which the requested post is and open it's page"""
                 post = get_object_or_404(Post, id=post_id)
                 if not post.thread:
                     return redirect(thread, post_id=post.id)
                 else:
                     return redirect(reverse(thread, kwargs={'post_id': post.thread.id})
                                     + '#' + str(post.id))
             def authors(request):
                 context = _init_default_context(request)
                 context['authors'] = boards.authors.authors
                 return render(request, 'boards/authors.html', context)
             def delete(request, post_id):
                 user = _get_user(request)
                 post = get_object_or_404(Post, id=post_id)
                 if user.is_moderator():
                     # TODO Show confirmation page before deletion
                     Post.objects.delete_post(post)
                 if not post.thread:
                     return _redirect_to_next(request)
                 else:
                     return redirect(thread, post_id=post.thread.id)
             def ban(request, post_id):
                 user = _get_user(request)
                 post = get_object_or_404(Post, id=post_id)
                 if user.is_moderator():
                     # TODO Show confirmation page before ban
                     Ban.objects.get_or_create(ip=post.poster_ip)
                 return _redirect_to_next(request)
             def you_are_banned(request):
                 context = _init_default_context(request)
                 return render(request, 'boards/staticpages/banned.html', context)
             def page_404(request):
                 context = _init_default_context(request)
                 return render(request, 'boards/404.html', context)
             def tag_subscribe(request, tag_name):
                 user = _get_user(request)
                 tag = get_object_or_404(Tag, name=tag_name)
                 if not tag in user.fav_tags.all():
                     user.fav_tags.add(tag)
                 return _redirect_to_next(request)
             def tag_unsubscribe(request, tag_name):
                 user = _get_user(request)
                 tag = get_object_or_404(Tag, name=tag_name)
                 if tag in user.fav_tags.all():
                     user.fav_tags.remove(tag)
                 return _redirect_to_next(request)
             def static_page(request, name):
                 context = _init_default_context(request)
                 return render(request, 'boards/staticpages/' + name + '.html', context)
             def _get_theme(request, user=None):
                 """Get user's CSS theme"""
                 if not user:
                     user = _get_user(request)
                 theme = user.get_setting('theme')
                 if not theme:
                     theme = neboard.settings.DEFAULT_THEME
                 return theme
-            def _get_client_ip(request):
-                x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
-                if x_forwarded_for:
-                    ip = x_forwarded_for.split(',')[-1].strip()
-                else:
-                    ip = request.META.get('REMOTE_ADDR')
-                return ip
             def _init_default_context(request):
                 """Create context with default values that are used in most views"""
                 context = RequestContext(request)
                 user = _get_user(request)
                 context['user'] = user
                 context['tags'] = user.get_sorted_fav_tags()
                 context['theme'] = _get_theme(request, user)
                 moderate = user.get_setting(SETTING_MODERATE)
                 if moderate == 'True':
                     context['moderator'] = user.is_moderator()
                 else:
                     context['moderator'] = False
                 return context
             def _get_user(request):
                 """Get current user from the session"""
                 session = request.session
                 if not 'user_id' in session:
                     request.session.save()
                     md5 = hashlib.md5()
                     md5.update(session.session_key)
                     new_id = md5.hexdigest()
                     time_now = timezone.now()
                     user = User.objects.create(user_id=new_id, rank=RANK_USER,
                                                registration_time=time_now)
                     session['user_id'] = user.id
                 else:
                     user = User.objects.get(id=session['user_id'])
                 return user
             def _redirect_to_next(request):
                 if 'next' in request.GET:
                     next_page = request.GET['next']
                     return HttpResponseRedirect(next_page)
                 else:
                     return redirect(index)

neboard/settings.py

0 +2 -1

             # Django settings for neboard project.
             import os
             import markdown
             from boards.mdx_neboard import markdown_extended
             DEBUG = True
             TEMPLATE_DEBUG = DEBUG
             ADMINS = (
                 # ('Your Name', 'your_email@example.com'),
                 ('admin', 'admin@example.com')
             )
             MANAGERS = ADMINS
             DATABASES = {
                 'default': {
                     'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
                     'NAME': 'database.db',                      # Or path to database file if using sqlite3.
                     'USER': '',                      # Not used with sqlite3.
                     'PASSWORD': '',                  # Not used with sqlite3.
                     'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
                     'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
                 }
             }
             CACHES = {
                 'default': {
                     'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
                     'LOCATION': 'neboard_cache',
                 }
             }
             # Local time zone for this installation. Choices can be found here:
             # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
             # although not all choices may be available on all operating systems.
             # In a Windows environment this must be set to your system time zone.
             TIME_ZONE = 'Europe/Kiev'
             # Language code for this installation. All choices can be found here:
             # http://www.i18nguy.com/unicode/language-identifiers.html
             LANGUAGE_CODE = 'en'
             SITE_ID = 1
             # If you set this to False, Django will make some optimizations so as not
             # to load the internationalization machinery.
             USE_I18N = True
             # If you set this to False, Django will not format dates, numbers and
             # calendars according to the current locale.
             USE_L10N = True
             # If you set this to False, Django will not use timezone-aware datetimes.
             USE_TZ = True
             # Absolute filesystem path to the directory that will hold user-uploaded files.
             # Example: "/home/media/media.lawrence.com/media/"
             MEDIA_ROOT = './media/'
             # URL that handles the media served from MEDIA_ROOT. Make sure to use a
             # trailing slash.
             # Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
             MEDIA_URL = '/media/'
             # Absolute path to the directory static files should be collected to.
             # Don't put anything in this directory yourself; store your static files
             # in apps' "static/" subdirectories and in STATICFILES_DIRS.
             # Example: "/home/media/media.lawrence.com/static/"
             STATIC_ROOT = ''
             # URL prefix for static files.
             # Example: "http://media.lawrence.com/static/"
             STATIC_URL = '/static/'
             # Additional locations of static files
             # It is really a hack, put real paths, not related
             STATICFILES_DIRS = (
                 os.path.dirname(__file__) + '/boards/static',
             #    '/d/work/python/django/neboard/neboard/boards/static',
                 # Put strings here, like "/home/html/static" or "C:/www/django/static".
                 # Always use forward slashes, even on Windows.
                 # Don't forget to use absolute paths, not relative paths.
             )
             # List of finder classes that know how to find static files in
             # various locations.
             STATICFILES_FINDERS = (
                 'django.contrib.staticfiles.finders.FileSystemFinder',
                 'django.contrib.staticfiles.finders.AppDirectoriesFinder',
             #    'django.contrib.staticfiles.finders.DefaultStorageFinder',
             )
             # Make this unique, and don't share it with anybody.
             SECRET_KEY = '@1rc$o(7=tt#kd+4s$u6wchm**z^)4x90)7f6z(i&amp;55@o11*8o'
             # List of callables that know how to import templates from various sources.
             TEMPLATE_LOADERS = (
                 'django.template.loaders.filesystem.Loader',
                 'django.template.loaders.app_directories.Loader',
             #     'django.template.loaders.eggs.Loader',
             )
             TEMPLATE_CONTEXT_PROCESSORS = (
                 'django.core.context_processors.media',
                 'django.core.context_processors.static',
                 'django.core.context_processors.request',
                 'django.contrib.auth.context_processors.auth',
             )
             MIDDLEWARE_CLASSES = (
                 'django.contrib.sessions.middleware.SessionMiddleware',
                 'django.middleware.locale.LocaleMiddleware',
                 'django.middleware.common.CommonMiddleware',
             #    'django.middleware.csrf.CsrfViewMiddleware',
                 'django.contrib.auth.middleware.AuthenticationMiddleware',
                 'django.contrib.messages.middleware.MessageMiddleware',
                 # Uncomment the next line for simple clickjacking protection:
-                # 'django.middleware.clickjacking.XFrameOptionsMiddleware',
+                # 'django.middleware.clickjacking.XFrameOptionsMiddleware'
+                'boards.middlewares.BanMiddleware',
             )
             ROOT_URLCONF = 'neboard.urls'
             # Python dotted path to the WSGI application used by Django's runserver.
             WSGI_APPLICATION = 'neboard.wsgi.application'
             TEMPLATE_DIRS = (
                 # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
                 # Always use forward slashes, even on Windows.
                 # Don't forget to use absolute paths, not relative paths.
                 'templates',
             )
             INSTALLED_APPS = (
                 'django.contrib.auth',
                 'django.contrib.contenttypes',
                 'django.contrib.sessions',
                 # 'django.contrib.sites',
                 'django.contrib.messages',
                 'django.contrib.staticfiles',
                 # Uncomment the next line to enable the admin:
                  'django.contrib.admin',
                 # Uncomment the next line to enable admin documentation:
                 # 'django.contrib.admindocs',
                 'django.contrib.markup',
                 'django_cleanup',
                 'boards',
                 'captcha',
                 'south',
             )
             # TODO: NEED DESIGN FIXES
             CAPTCHA_OUTPUT_FORMAT = (u' %(hidden_field)s '
                                      u'<div class="form-label">%(image)s</div>'
                                      u'<div class="form-text">%(text_field)s</div>')
             # A sample logging configuration. The only tangible logging
             # performed by this configuration is to send an email to
             # the site admins on every HTTP 500 error when DEBUG=False.
             # See http://docs.djangoproject.com/en/dev/topics/logging for
             # more details on how to customize your logging configuration.
             LOGGING = {
                 'version': 1,
                 'disable_existing_loggers': False,
                 'filters': {
                     'require_debug_false': {
                         '()': 'django.utils.log.RequireDebugFalse'
                     }
                 },
                 'handlers': {
                     'mail_admins': {
                         'level': 'ERROR',
                         'filters': ['require_debug_false'],
                         'class': 'django.utils.log.AdminEmailHandler'
                     }
                 },
                 'loggers': {
                     'django.request': {
                         'handlers': ['mail_admins'],
                         'level': 'ERROR',
                         'propagate': True,
                     },
                 }
             }
             MARKUP_FIELD_TYPES = (
                 ('markdown', markdown_extended),
             )
             # Custom imageboard settings
             MAX_POSTS_PER_THREAD = 10  # Thread bumplimit
             MAX_THREAD_COUNT = 500  # Old threads will be deleted to preserve this count
             THREADS_PER_PAGE = 10
             SITE_NAME = 'Neboard'
             THEMES = [
                 ('md', 'Mystic Dark'),
                 ('sw', 'Snow White'),
                 ('pg', 'Photon Gray'),
             ]
             DEFAULT_THEME = 'md'
             POPULAR_TAGS = 10
             LAST_REPLIES_COUNT = 3
             ENABLE_CAPTCHA = False
             # if user tries to post before CAPTCHA_DEFAULT_SAFE_TIME. Captcha will be shown
             CAPTCHA_DEFAULT_SAFE_TIME = 30  # seconds
             POSTING_DELAY = 30  # seconds
             # Debug mode middlewares
             if DEBUG:
                 MIDDLEWARE_CLASSES += ('boards.profiler.ProfilerMiddleware',)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages