everything and has a huge dependency chain, so it should not be used for

  anything else. TODO.

  The base class of controllers, with lots of model knowledge.

``lib/auth.py``

import re

from kallithea.config.middleware.pygrack import make_wsgi_app

from kallithea.lib import hooks

log = logging.getLogger(__name__)

}

    scm_alias = 'git'

    @classmethod

    def parse_request(cls, environ):

        m = GIT_PROTO_PAT.match(path_info)

        if m is None:

            return None

import mercurial.hgweb

from kallithea.lib.utils import make_ui

from kallithea.lib.utils2 import safe_bytes

    }

    scm_alias = 'hg'

        http_accept = environ.get('HTTP_ACCEPT', '')

        if not http_accept.startswith('application/mercurial'):

            return None

        if not path_info.startswith('/'): # it must!

            return None

import logging

import time

log = logging.getLogger(__name__)

    def __call__(self, environ, start_response):

        meter = Meter(start_response)

        description = "Request from %s for %s" % (

        )

        log.info("%s received", description)

        try:

from whoosh.qparser.dateparse import DateParserPlugin

from whoosh.qparser.default import QueryParser

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.indexers import JOURNAL_SCHEMA

from kallithea.lib.page import Page

from kallithea.lib.utils2 import remove_prefix, remove_suffix, safe_int

    return user_log

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

                           filter=c.search_term)

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib import auth_modules, webutils

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import AuthSettingsForm

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin')

        log.debug('defaults: %s', defaults)

        return formencode.htmlfill.render(

            defaults=c.defaults,

            errors=errors,

            prefix_error=False,

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import DefaultsForm

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin')

        defaults = db.Setting.get_default_repo_settings()

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

            defaults = errors.value

            return htmlfill.render(

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

from tg.i18n import ugettext as _

from webob.exc import HTTPForbidden, HTTPFound, HTTPNotFound

from kallithea.lib import auth, webutils

from kallithea.lib.auth import LoginRequired

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int, safe_str, time_to_datetime

from kallithea.lib.vcs.exceptions import NodeNotChangedError, VCSError

log = logging.getLogger(__name__)

    def __load_defaults(self, extra_values=None):

        c.lifetime_values = [

        p = safe_int(request.GET.get('page'), 1)

        c.gists_pager = Page(c.gists, page=p, items_per_page=10,

                             **url_params)

    @LoginRequired()

    def create(self):

            defaults = errors.value

            return formencode.htmlfill.render(

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

    @LoginRequired()

    def new(self, format='html'):

        self.__load_defaults()

    @LoginRequired()

    def delete(self, gist_id):

            )

            response.content_type = 'text/plain'

            return content

    @LoginRequired()

    def edit(self, gist_id, format='html'):

            raise HTTPNotFound()

        self.__load_defaults(extra_values=('0', _('Unmodified')))

        if request.POST:

            rpost = request.POST

        return rendered

    @LoginRequired()

    def check_revision(self, gist_id):

        c.gist = db.Gist.get_or_404(gist_id)

        last_rev = c.gist.scm_instance.get_changeset()

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib import auth_modules, webutils

from kallithea.lib.auth import AuthUser, LoginRequired

from kallithea.lib.utils2 import generate_api_key, safe_int

from kallithea.lib.webutils import url

from kallithea.model import db, meta

log = logging.getLogger(__name__)

    @LoginRequired()

    def _before(self, *args, **kwargs):

            except formencode.Invalid as errors:

                return htmlfill.render(

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

        if update:

            raise HTTPFound(location='my_account')

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

                webutils.flash(_("Successfully updated password"), category='success')

            except formencode.Invalid as errors:

                return htmlfill.render(

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                log.error(traceback.format_exc())

                webutils.flash(_('Error occurred during update of user password'),

                        category='error')

    def my_account_repos(self):

        c.active = 'repos'

        # data used to render the grid

        c.data = self._load_my_repos_data()

    def my_account_watched(self):

        c.active = 'watched'

        # data used to render the grid

        c.data = self._load_my_repos_data(watched=True)

    def my_account_perms(self):

        c.active = 'perms'

        self.__load_data()

        c.perm_user = AuthUser(user_id=request.authuser.user_id)

    def my_account_emails(self):

        c.active = 'emails'

        c.user_email_map = db.UserEmailMap.query() \

            .filter(db.UserEmailMap.user == c.user).all()

    def my_account_emails_add(self):

        email = request.POST.get('new_email')

        c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]

        c.user_api_keys = ApiKeyModel().get_api_keys(request.authuser.user_id,

                                                     show_expired=show_expired)

    def my_account_api_keys_add(self):

        lifetime = safe_int(request.POST.get('lifetime'), -1)

        raise HTTPFound(location=url('my_account_api_keys'))

    def my_account_ssh_keys(self):

        c.active = 'ssh_keys'

        self.__load_data()

        c.user_ssh_keys = SshKeyModel().get_ssh_keys(request.authuser.user_id)

    def my_account_ssh_keys_add(self):

        description = request.POST.get('description')

        public_key = request.POST.get('public_key')

            webutils.flash(e.args[0], category='error')

        raise HTTPFound(location=url('my_account_ssh_keys'))

    def my_account_ssh_keys_delete(self):

        fingerprint = request.POST.get('del_public_key_fingerprint')

        try:

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib import webutils

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import DefaultPermissionsForm

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin')

                defaults = errors.value

                return htmlfill.render(

                    defaults=defaults,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                defaults['default_fork'] = p.permission.permission_name

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

        c.user_ip_map = db.UserIpMap.query() \

                        .filter(db.UserIpMap.user == c.user).all()

    def permission_perms(self):

        c.active = 'perms'

        c.user = db.User.get_default_user()

        c.perm_user = AuthUser(dbuser=c.user)

from webob.exc import HTTPForbidden, HTTPFound, HTTPInternalServerError, HTTPNotFound

import kallithea.lib.helpers as h

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoGroupPermissionLevelDecorator, LoginRequired

from kallithea.lib.utils2 import safe_int

from kallithea.lib.webutils import url

from kallithea.model import db, meta

log = logging.getLogger(__name__)

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

            "records": repo_groups_data

        }

    def create(self):

        self.__load_defaults()

            # TODO: in future action_logger(, '', '', '')

        except formencode.Invalid as errors:

            return htmlfill.render(

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

        self.__load_defaults()

        return htmlfill.render(

            defaults={'parent_group_id': parent_group_id},

            errors={},

            prefix_error=False,

        except formencode.Invalid as errors:

            c.active = 'settings'

            return htmlfill.render(

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                                               repo_groups_list=repo_groups_list,

                                               short_name=True)

    @HasRepoGroupPermissionLevelDecorator('admin')

    def edit(self, group_name):

        defaults = self.__load_data(c.repo_group.group_id)

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        c.active = 'advanced'

        c.repo_group = db.RepoGroup.guess_instance(group_name)

    @HasRepoGroupPermissionLevelDecorator('admin')

    def edit_repo_group_perms(self, group_name):

        defaults = self.__load_data(c.repo_group.group_id)

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

from webob.exc import HTTPForbidden, HTTPFound, HTTPInternalServerError, HTTPNotFound

import kallithea

from kallithea.lib import webutils

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired, NotAnonymous

from kallithea.lib.exceptions import AttachedForksError

from kallithea.lib.utils2 import safe_int

from kallithea.lib.vcs import RepositoryError

log = logging.getLogger(__name__)

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

        # data used to render the grid

        c.data = repos_data

    @NotAnonymous()

    def create(self):

        except formencode.Invalid as errors:

            log.info(errors)

            return htmlfill.render(

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

        defaults.update({'repo_group': parent_group})

        return htmlfill.render(

            defaults=defaults,

            errors={},

            prefix_error=False,

        c.task_id = request.GET.get('task_id')

        if not c.repo:

            raise HTTPNotFound()

    @LoginRequired()

    def repo_check(self, repo_name):

        c.repo = repo_name

        task_id = request.GET.get('task_id')

            defaults = self.__load_data()

            defaults.update(errors.value)

            return htmlfill.render(

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

            .filter(db.RepositoryField.repository == c.repo_info).all()

        c.active = 'settings'

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

        defaults = RepoModel()._get_defaults(repo_name)

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

        if request.POST:

            raise HTTPFound(location=url('repo_edit_fields'))

    @HasRepoPermissionLevelDecorator('admin')

    def create_repo_field(self, repo_name):

        if request.POST:

            raise HTTPFound(location=url('repo_edit_advanced'))

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

                webutils.flash(_('An error occurred during pull from remote location'),

                        category='error')

            raise HTTPFound(location=url('edit_repo_remote', repo_name=c.repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def edit_statistics(self, repo_name):

                        category='error')

            raise HTTPFound(location=url('edit_repo_statistics', repo_name=c.repo_name))

from webob.exc import HTTPFound

import kallithea

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.utils import repo2db_mapper, set_app_settings

from kallithea.lib.utils2 import safe_str

from kallithea.lib.vcs import VCSError

log = logging.getLogger(__name__)

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

                form_result = application_form.to_python(dict(request.POST))

            except formencode.Invalid as errors:

                return htmlfill.render(

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

                form_result = application_form.to_python(dict(request.POST))

            except formencode.Invalid as errors:

                return htmlfill.render(

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

                form_result = application_form.to_python(dict(request.POST))

            except formencode.Invalid as errors:

                return htmlfill.render(

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

        c.ini = kallithea.CONFIG

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

        c.custom_hooks = db.Ui.get_custom_hooks()

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

            setattr(c, key, val)

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

from webob.exc import HTTPFound, HTTPInternalServerError

import kallithea.lib.helpers as h

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAnyDecorator, HasUserGroupPermissionLevelDecorator, LoginRequired

from kallithea.lib.exceptions import RepoGroupAssignmentError, UserGroupsAssignedException

from kallithea.lib.utils2 import safe_int, safe_str

from kallithea.lib.webutils import url

log = logging.getLogger(__name__)

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

            "records": user_groups_data

        }

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def create(self):

            meta.Session().commit()

        except formencode.Invalid as errors:

            return htmlfill.render(

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def new(self, format='html'):

    @HasUserGroupPermissionLevelDecorator('admin')

    def update(self, id):

            })

            return htmlfill.render(

                defaults=defaults,

                errors=e,

                prefix_error=False,

        defaults = self.__load_defaults(id)

        return htmlfill.render(

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

                             p.permission.permission_name})