gists: fixes for tests and cleanup code that is now handled by the form deserializer

rhodecode/apps/gist/tests/test_admin_gists.py

@@ -1,391 +1,391 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 from rhodecode.lib import helpers as h
 from rhodecode.model.db import User, Gist
 from rhodecode.model.gist import GistModel
 from rhodecode.model.meta import Session
 from rhodecode.tests import (
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,
     TestController, assert_session_flash)
 
 
 def route_path(name, params=None, **kwargs):
     import urllib.request, urllib.parse, urllib.error
     from rhodecode.apps._base import ADMIN_PREFIX
 
     base_url = {
         'gists_show': ADMIN_PREFIX + '/gists',
         'gists_new': ADMIN_PREFIX + '/gists/new',
         'gists_create': ADMIN_PREFIX + '/gists/create',
         'gist_show': ADMIN_PREFIX + '/gists/{gist_id}',
         'gist_delete': ADMIN_PREFIX + '/gists/{gist_id}/delete',
         'gist_edit': ADMIN_PREFIX + '/gists/{gist_id}/edit',
         'gist_edit_check_revision': ADMIN_PREFIX + '/gists/{gist_id}/edit/check_revision',
         'gist_update': ADMIN_PREFIX + '/gists/{gist_id}/update',
         'gist_show_rev': ADMIN_PREFIX + '/gists/{gist_id}/rev/{revision}',
         'gist_show_formatted': ADMIN_PREFIX + '/gists/{gist_id}/rev/{revision}/{format}',
         'gist_show_formatted_path': ADMIN_PREFIX + '/gists/{gist_id}/rev/{revision}/{format}/{f_path}',
 
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.parse.urlencode(params))
     return base_url
 
 
 class GistUtility(object):
 
     def __init__(self):
         self._gist_ids = []
 
     def __call__(
             self, f_name, content='some gist', lifetime=-1,
             description='gist-desc', gist_type='public',
             acl_level=Gist.GIST_PUBLIC, owner=TEST_USER_ADMIN_LOGIN):
         gist_mapping = {
             f_name: {'content': content}
         }
         user = User.get_by_username(owner)
         gist = GistModel().create(
             description, owner=user, gist_mapping=gist_mapping,
             gist_type=gist_type, lifetime=lifetime, gist_acl_level=acl_level)
         Session().commit()
         self._gist_ids.append(gist.gist_id)
         return gist
 
     def cleanup(self):
         for gist_id in self._gist_ids:
             gist = Gist.get(gist_id)
             if gist:
                 Session().delete(gist)
 
         Session().commit()
 
 
 @pytest.fixture()
 def create_gist(request):
     gist_utility = GistUtility()
     request.addfinalizer(gist_utility.cleanup)
     return gist_utility
 
 
 class TestGistsController(TestController):
 
     def test_index_empty(self, create_gist):
         self.log_user()
         response = self.app.get(route_path('gists_show'))
         response.mustcontain('data: [],')
 
     def test_index(self, create_gist):
         self.log_user()
         g1 = create_gist('gist1')
         g2 = create_gist('gist2', lifetime=1400)
         g3 = create_gist('gist3', description='gist3-desc')
         g4 = create_gist('gist4', gist_type='private').gist_access_id
         response = self.app.get(route_path('gists_show'))
 
         response.mustcontain(g1.gist_access_id)
         response.mustcontain(g2.gist_access_id)
         response.mustcontain(g3.gist_access_id)
         response.mustcontain('gist3-desc')
         response.mustcontain(no=[g4])
 
         # Expiration information should be visible
         expires_tag = '%s' % h.age_component(
             h.time_to_utcdatetime(g2.gist_expires))
         response.mustcontain(expires_tag.replace('"', '\\"'))
 
     def test_index_private_gists(self, create_gist):
         self.log_user()
         gist = create_gist('gist5', gist_type='private')
         response = self.app.get(route_path('gists_show', params=dict(private=1)))
 
         # and privates
         response.mustcontain(gist.gist_access_id)
 
     def test_index_show_all(self, create_gist):
         self.log_user()
         create_gist('gist1')
         create_gist('gist2', lifetime=1400)
         create_gist('gist3', description='gist3-desc')
         create_gist('gist4', gist_type='private')
 
         response = self.app.get(route_path('gists_show', params=dict(all=1)))
 
         assert len(GistModel.get_all()) == 4
         # and privates
         for gist in GistModel.get_all():
             response.mustcontain(gist.gist_access_id)
 
     def test_index_show_all_hidden_from_regular(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         create_gist('gist2', gist_type='private')
         create_gist('gist3', gist_type='private')
         create_gist('gist4', gist_type='private')
 
         response = self.app.get(route_path('gists_show', params=dict(all=1)))
 
         assert len(GistModel.get_all()) == 3
         # since we don't have access to private in this view, we
         # should see nothing
         for gist in GistModel.get_all():
             response.mustcontain(no=[gist.gist_access_id])
 
     def test_create(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'gist test',
                     'filename': 'foo',
                     'gist_type': 'public',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
             status=302)
         response = response.follow()
         response.mustcontain('added file: foo')
         response.mustcontain('gist test')
 
     def test_create_with_path_with_dirs(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'gist test',
                     'filename': '/home/foo',
                     'gist_type': 'public',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
             status=200)
         response.mustcontain('Filename /home/foo cannot be inside a directory')
 
     def test_access_expired_gist(self, create_gist):
         self.log_user()
         gist = create_gist('never-see-me')
         gist.gist_expires = 0  # 1970
         Session().add(gist)
         Session().commit()
 
         self.app.get(route_path('gist_show', gist_id=gist.gist_access_id),
                      status=404)
 
     def test_create_private(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'private gist test',
                     'filename': 'private-foo',
                     'gist_type': 'private',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
             status=302)
         response = response.follow()
         response.mustcontain('added file: private-foo<')
         response.mustcontain('private gist test')
         response.mustcontain('Private Gist')
         # Make sure private gists are not indexed by robots
         response.mustcontain(
             '<meta name="robots" content="noindex, nofollow">')
 
     def test_create_private_acl_private(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'private gist test',
                     'filename': 'private-foo',
                     'gist_type': 'private',
                     'gist_acl_level': Gist.ACL_LEVEL_PRIVATE,
                     'csrf_token': self.csrf_token},
             status=302)
         response = response.follow()
         response.mustcontain('added file: private-foo<')
         response.mustcontain('private gist test')
         response.mustcontain('Private Gist')
         # Make sure private gists are not indexed by robots
         response.mustcontain(
             '<meta name="robots" content="noindex, nofollow">')
 
     def test_create_with_description(self):
         self.log_user()
         response = self.app.post(
             route_path('gists_create'),
             params={'lifetime': -1,
                     'content': 'gist test',
                     'filename': 'foo-desc',
                     'description': 'gist-desc',
                     'gist_type': 'public',
                     'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
                     'csrf_token': self.csrf_token},
              status=302)
         response = response.follow()
         response.mustcontain('added file: foo-desc')
         response.mustcontain('gist test')
         response.mustcontain('gist-desc')
 
     def test_create_public_with_anonymous_access(self):
         self.log_user()
         params = {
             'lifetime': -1,
             'content': 'gist test',
             'filename': 'foo-desc',
             'description': 'gist-desc',
             'gist_type': 'public',
             'gist_acl_level': Gist.ACL_LEVEL_PUBLIC,
             'csrf_token': self.csrf_token
         }
         response = self.app.post(
             route_path('gists_create'), params=params, status=302)
         self.logout_user()
         response = response.follow()
         response.mustcontain('added file: foo-desc')
         response.mustcontain('gist test')
         response.mustcontain('gist-desc')
 
     def test_new(self):
         self.log_user()
         self.app.get(route_path('gists_new'))
 
     def test_delete(self, create_gist):
         self.log_user()
         gist = create_gist('delete-me')
         response = self.app.post(
             route_path('gist_delete', gist_id=gist.gist_id),
             params={'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Deleted gist %s' % gist.gist_id)
 
     def test_delete_normal_user_his_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist('delete-me', owner=TEST_USER_REGULAR_LOGIN)
 
         response = self.app.post(
             route_path('gist_delete', gist_id=gist.gist_id),
             params={'csrf_token': self.csrf_token})
         assert_session_flash(response, 'Deleted gist %s' % gist.gist_id)
 
     def test_delete_normal_user_not_his_own_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist('delete-me-2')
 
         self.app.post(
             route_path('gist_delete', gist_id=gist.gist_id),
             params={'csrf_token': self.csrf_token}, status=404)
 
     def test_show(self, create_gist):
         gist = create_gist('gist-show-me')
         response = self.app.get(route_path('gist_show', gist_id=gist.gist_access_id))
 
         response.mustcontain('added file: gist-show-me<')
 
         assert_response = response.assert_response()
         assert_response.element_equals_to(
             'div.rc-user span.user',
             '<a href="/_profiles/test_admin">test_admin</a>')
 
         response.mustcontain('gist-desc')
 
     def test_show_without_hg(self, create_gist):
         with mock.patch(
                 'rhodecode.lib.vcs.settings.ALIASES', ['git']):
             gist = create_gist('gist-show-me-again')
             self.app.get(
                 route_path('gist_show', gist_id=gist.gist_access_id), status=200)
 
     def test_show_acl_private(self, create_gist):
         gist = create_gist('gist-show-me-only-when-im-logged-in',
                            acl_level=Gist.ACL_LEVEL_PRIVATE)
         self.app.get(
             route_path('gist_show', gist_id=gist.gist_access_id), status=404)
 
         # now we log-in we should see thi gist
         self.log_user()
         response = self.app.get(
             route_path('gist_show', gist_id=gist.gist_access_id))
         response.mustcontain('added file: gist-show-me-only-when-im-logged-in')
 
         assert_response = response.assert_response()
         assert_response.element_equals_to(
             'div.rc-user span.user',
             '<a href="/_profiles/test_admin">test_admin</a>')
         response.mustcontain('gist-desc')
 
     def test_show_as_raw(self, create_gist):
         gist = create_gist('gist-show-me', content='GIST CONTENT')
         response = self.app.get(
             route_path('gist_show_formatted',
                        gist_id=gist.gist_access_id, revision='tip',
                        format='raw'))
-        assert response.body == 'GIST CONTENT'
+        assert response.text == 'GIST CONTENT'
 
     def test_show_as_raw_individual_file(self, create_gist):
         gist = create_gist('gist-show-me-raw', content='GIST BODY')
         response = self.app.get(
             route_path('gist_show_formatted_path',
                        gist_id=gist.gist_access_id, format='raw',
                        revision='tip', f_path='gist-show-me-raw'))
-        assert response.body == 'GIST BODY'
+        assert response.text == 'GIST BODY'
 
     def test_edit_page(self, create_gist):
         self.log_user()
         gist = create_gist('gist-for-edit', content='GIST EDIT BODY')
         response = self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id))
         response.mustcontain('GIST EDIT BODY')
 
     def test_edit_page_non_logged_user(self, create_gist):
         gist = create_gist('gist-for-edit', content='GIST EDIT BODY')
         self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id),
                      status=302)
 
     def test_edit_normal_user_his_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist('gist-for-edit', owner=TEST_USER_REGULAR_LOGIN)
         self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id,
                                 status=200))
 
     def test_edit_normal_user_not_his_own_gist(self, create_gist):
         self.log_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         gist = create_gist('delete-me')
         self.app.get(route_path('gist_edit', gist_id=gist.gist_access_id),
                      status=404)
 
     def test_user_first_name_is_escaped(self, user_util, create_gist):
         xss_atack_string = '"><script>alert(\'First Name\')</script>'
         xss_escaped_string = h.html_escape(h.escape(xss_atack_string))
         password = 'test'
         user = user_util.create_user(
             firstname=xss_atack_string, password=password)
         create_gist('gist', gist_type='public', owner=user.username)
         response = self.app.get(route_path('gists_show'))
         response.mustcontain(xss_escaped_string)
 
     def test_user_last_name_is_escaped(self, user_util, create_gist):
         xss_atack_string = '"><script>alert(\'Last Name\')</script>'
         xss_escaped_string = h.html_escape(h.escape(xss_atack_string))
         password = 'test'
         user = user_util.create_user(
             lastname=xss_atack_string, password=password)
         create_gist('gist', gist_type='public', owner=user.username)
         response = self.app.get(route_path('gists_show'))
         response.mustcontain(xss_escaped_string)

rhodecode/apps/gist/views.py

@@ -1,386 +1,378 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2013-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import time
 import logging
 
 import formencode
 import formencode.htmlfill
 import peppercorn
 
 from pyramid.httpexceptions import HTTPNotFound, HTTPFound, HTTPBadRequest
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode.apps._base import BaseAppView
 from rhodecode.lib import helpers as h, ext_json
 from rhodecode.lib.auth import LoginRequired, NotAnonymous, CSRFRequired
 from rhodecode.lib.utils2 import time_to_datetime
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.vcs.exceptions import VCSError, NodeNotChangedError
 from rhodecode.model.gist import GistModel
 from rhodecode.model.meta import Session
 from rhodecode.model.db import Gist, User, or_
 from rhodecode.model import validation_schema
 from rhodecode.model.validation_schema.schemas import gist_schema
 
 
 log = logging.getLogger(__name__)
 
 
 class GistView(BaseAppView):
 
     def load_default_context(self):
         _ = self.request.translate
         c = self._get_local_tmpl_context()
         c.user = c.auth_user.get_instance()
 
         c.lifetime_values = [
             (-1, _('forever')),
             (5, _('5 minutes')),
             (60, _('1 hour')),
             (60 * 24, _('1 day')),
             (60 * 24 * 30, _('1 month')),
         ]
 
         c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]
         c.acl_options = [
             (Gist.ACL_LEVEL_PRIVATE, _("Requires registered account")),
             (Gist.ACL_LEVEL_PUBLIC, _("Can be accessed by anonymous users"))
         ]
 
         return c
 
     @LoginRequired()
     def gist_show_all(self):
         c = self.load_default_context()
 
         not_default_user = self._rhodecode_user.username != User.DEFAULT_USER
         c.show_private = self.request.GET.get('private') and not_default_user
         c.show_public = self.request.GET.get('public') and not_default_user
         c.show_all = self.request.GET.get('all') and self._rhodecode_user.admin
 
         gists = _gists = Gist().query()\
             .filter(or_(Gist.gist_expires == -1, Gist.gist_expires >= time.time()))\
             .order_by(Gist.created_on.desc())
 
         c.active = 'public'
         # MY private
         if c.show_private and not c.show_public:
             gists = _gists.filter(Gist.gist_type == Gist.GIST_PRIVATE)\
                         .filter(Gist.gist_owner == self._rhodecode_user.user_id)
             c.active = 'my_private'
         # MY public
         elif c.show_public and not c.show_private:
             gists = _gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)\
                         .filter(Gist.gist_owner == self._rhodecode_user.user_id)
             c.active = 'my_public'
         # MY public+private
         elif c.show_private and c.show_public:
             gists = _gists.filter(or_(Gist.gist_type == Gist.GIST_PUBLIC,
                                       Gist.gist_type == Gist.GIST_PRIVATE))\
                         .filter(Gist.gist_owner == self._rhodecode_user.user_id)
             c.active = 'my_all'
         # Show all by super-admin
         elif c.show_all:
             c.active = 'all'
             gists = _gists
 
         # default show ALL public gists
         if not c.show_public and not c.show_private and not c.show_all:
             gists = _gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)
             c.active = 'public'
 
         _render = self.request.get_partial_renderer(
             'rhodecode:templates/data_table/_dt_elements.mako')
 
         data = []
 
         for gist in gists:
             data.append({
                 'created_on': _render('gist_created', gist.created_on),
                 'created_on_raw': gist.created_on,
                 'type': _render('gist_type', gist.gist_type),
                 'access_id': _render('gist_access_id', gist.gist_access_id, gist.owner.full_contact),
                 'author': _render('gist_author', gist.owner.full_contact, gist.created_on, gist.gist_expires),
                 'author_raw': h.escape(gist.owner.full_contact),
                 'expires': _render('gist_expires', gist.gist_expires),
                 'description': _render('gist_description', gist.gist_description)
             })
         c.data = ext_json.str_json(data)
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     def gist_new(self):
         c = self.load_default_context()
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def gist_create(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         data = dict(self.request.POST)
-        data['filename'] = data.get('filename') or Gist.DEFAULT_FILENAME
+
+        filename = data.pop('filename', '') or Gist.DEFAULT_FILENAME
 
         data['nodes'] = [{
-            'filename': data['filename'],
-            'content': data.get('content'),
-            'mimetype': data.get('mimetype')  # None is autodetect
+            'filename': filename,
+            'content': data.pop('content', ''),
+            'mimetype': data.pop('mimetype', None)  # None is autodetect
         }]
-        gist_type = {
-            'public': Gist.GIST_PUBLIC,
-            'private': Gist.GIST_PRIVATE
-        }.get(data.get('gist_type')) or Gist.GIST_PRIVATE
-
-        data['gist_type'] = gist_type
-
-        data['gist_acl_level'] = (
-            data.get('gist_acl_level') or Gist.ACL_LEVEL_PRIVATE)
 
         schema = gist_schema.GistSchema().bind(
             lifetime_options=[x[0] for x in c.lifetime_values])
 
         try:
 
             schema_data = schema.deserialize(data)
+
             # convert to safer format with just KEYs so we sure no duplicates
-            schema_data['nodes'] = gist_schema.sequence_to_nodes(
-                schema_data['nodes'])
+            schema_data['nodes'] = gist_schema.sequence_to_nodes(schema_data['nodes'])
 
             gist = GistModel().create(
                 gist_id=schema_data['gistid'],  # custom access id not real ID
                 description=schema_data['description'],
                 owner=self._rhodecode_user.user_id,
                 gist_mapping=schema_data['nodes'],
                 gist_type=schema_data['gist_type'],
                 lifetime=schema_data['lifetime'],
                 gist_acl_level=schema_data['gist_acl_level']
             )
             Session().commit()
             new_gist_id = gist.gist_access_id
         except validation_schema.Invalid as errors:
             defaults = data
             errors = errors.asdict()
 
             if 'nodes.0.content' in errors:
                 errors['content'] = errors['nodes.0.content']
                 del errors['nodes.0.content']
             if 'nodes.0.filename' in errors:
                 errors['filename'] = errors['nodes.0.filename']
                 del errors['nodes.0.filename']
 
             data = render('rhodecode:templates/admin/gists/gist_new.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=defaults,
                 errors=errors,
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         except Exception:
             log.exception("Exception while trying to create a gist")
             h.flash(_('Error occurred during gist creation'), category='error')
             raise HTTPFound(h.route_url('gists_new'))
         raise HTTPFound(h.route_url('gist_show', gist_id=new_gist_id))
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def gist_delete(self):
         _ = self.request.translate
         gist_id = self.request.matchdict['gist_id']
 
         c = self.load_default_context()
         c.gist = Gist.get_or_404(gist_id)
 
         owner = c.gist.gist_owner == self._rhodecode_user.user_id
         if not (h.HasPermissionAny('hg.admin')() or owner):
             log.warning('Deletion of Gist was forbidden '
                         'by unauthorized user: `%s`', self._rhodecode_user)
             raise HTTPNotFound()
 
         GistModel().delete(c.gist)
         Session().commit()
         h.flash(_('Deleted gist %s') % c.gist.gist_access_id, category='success')
 
         raise HTTPFound(h.route_url('gists_show'))
 
     def _get_gist(self, gist_id):
 
         gist = Gist.get_or_404(gist_id)
 
         # Check if this gist is expired
         if gist.gist_expires != -1:
             if time.time() > gist.gist_expires:
                 log.error(
                     'Gist expired at %s', time_to_datetime(gist.gist_expires))
                 raise HTTPNotFound()
 
         # check if this gist requires a login
         is_default_user = self._rhodecode_user.username == User.DEFAULT_USER
         if gist.acl_level == Gist.ACL_LEVEL_PRIVATE and is_default_user:
             log.error("Anonymous user %s tried to access protected gist `%s`",
                       self._rhodecode_user, gist_id)
             raise HTTPNotFound()
         return gist
 
     @LoginRequired()
     def gist_show(self):
         gist_id = self.request.matchdict['gist_id']
 
         # TODO(marcink): expose those via matching dict
         revision = self.request.matchdict.get('revision', 'tip')
         f_path = self.request.matchdict.get('f_path', None)
         return_format = self.request.matchdict.get('format')
 
         c = self.load_default_context()
         c.gist = self._get_gist(gist_id)
         c.render = not self.request.GET.get('no-render', False)
 
         try:
             c.file_last_commit, c.files = GistModel().get_gist_files(
                 gist_id, revision=revision)
         except VCSError:
             log.exception("Exception in gist show")
             raise HTTPNotFound()
 
         if return_format == 'raw':
             content = '\n\n'.join([f.content for f in c.files
                                    if (f_path is None or f.path == f_path)])
             response = Response(content)
             response.content_type = 'text/plain'
             return response
         elif return_format:
             raise HTTPBadRequest()
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     def gist_edit(self):
         _ = self.request.translate
         gist_id = self.request.matchdict['gist_id']
         c = self.load_default_context()
         c.gist = self._get_gist(gist_id)
 
         owner = c.gist.gist_owner == self._rhodecode_user.user_id
         if not (h.HasPermissionAny('hg.admin')() or owner):
             raise HTTPNotFound()
 
         try:
             c.file_last_commit, c.files = GistModel().get_gist_files(gist_id)
         except VCSError:
             log.exception("Exception in gist edit")
             raise HTTPNotFound()
 
         if c.gist.gist_expires == -1:
             expiry = _('never')
         else:
             # this cannot use timeago, since it's used in select2 as a value
             expiry = h.age(h.time_to_datetime(c.gist.gist_expires))
 
         c.lifetime_values.append(
             (0, _('%(expiry)s - current value') % {'expiry': _(expiry)})
         )
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     def gist_update(self):
         _ = self.request.translate
         gist_id = self.request.matchdict['gist_id']
         c = self.load_default_context()
         c.gist = self._get_gist(gist_id)
 
         owner = c.gist.gist_owner == self._rhodecode_user.user_id
         if not (h.HasPermissionAny('hg.admin')() or owner):
             raise HTTPNotFound()
 
         data = peppercorn.parse(self.request.POST.items())
 
         schema = gist_schema.GistSchema()
         schema = schema.bind(
             # '0' is special value to leave lifetime untouched
             lifetime_options=[x[0] for x in c.lifetime_values] + [0],
         )
 
         try:
             schema_data = schema.deserialize(data)
             # convert to safer format with just KEYs so we sure no duplicates
             schema_data['nodes'] = gist_schema.sequence_to_nodes(
                 schema_data['nodes'])
 
             GistModel().update(
                 gist=c.gist,
                 description=schema_data['description'],
                 owner=c.gist.owner,
                 gist_mapping=schema_data['nodes'],
                 lifetime=schema_data['lifetime'],
                 gist_acl_level=schema_data['gist_acl_level']
             )
 
             Session().commit()
             h.flash(_('Successfully updated gist content'), category='success')
         except NodeNotChangedError:
             # raised if nothing was changed in repo itself. We anyway then
             # store only DB stuff for gist
             Session().commit()
             h.flash(_('Successfully updated gist data'), category='success')
         except validation_schema.Invalid as errors:
             errors = h.escape(errors.asdict())
             h.flash(_('Error occurred during update of gist {}: {}').format(
                 gist_id, errors), category='error')
         except Exception:
             log.exception("Exception in gist edit")
             h.flash(_('Error occurred during update of gist %s') % gist_id,
                     category='error')
 
         raise HTTPFound(h.route_url('gist_show', gist_id=gist_id))
 
     @LoginRequired()
     @NotAnonymous()
     def gist_edit_check_revision(self):
         _ = self.request.translate
         gist_id = self.request.matchdict['gist_id']
         c = self.load_default_context()
         c.gist = self._get_gist(gist_id)
 
         last_rev = c.gist.scm_instance().get_commit()
         success = True
         revision = self.request.GET.get('revision')
 
         if revision != last_rev.raw_id:
             log.error('Last revision %s is different then submitted %s',
                       revision, last_rev)
             # our gist has newer version than we
             success = False
 
         return {'success': success}