class AdminController(BaseController):

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

        super(AdminController, self)._before(*args, **kwargs)

from kallithea.model.db import Gist, User

from kallithea.lib import helpers as h

from kallithea.lib.base import BaseController, render, jsonify

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

from kallithea.lib.page import Page

from sqlalchemy.sql.expression import or_

            c.lifetime_values.append(extra_values)

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

    def index(self):

        not_default_user = not request.authuser.is_default_user

        c.show_private = request.GET.get('private') and not_default_user

        return render('admin/gists/index.html')

    @LoginRequired()

    def create(self):

        self.__load_defaults()

        gist_form = GistForm([x[0] for x in c.lifetime_values])()

        raise HTTPFound(location=url('gist', gist_id=new_gist_id))

    @LoginRequired()

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

        self.__load_defaults()

        return render('admin/gists/new.html')

    @LoginRequired()

    def delete(self, gist_id):

        gist = GistModel().get_gist(gist_id)

        owner = gist.owner_id == request.authuser.user_id

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

    def show(self, gist_id, revision='tip', format='html', f_path=None):

        c.gist = Gist.get_or_404(gist_id)

        return render('admin/gists/show.html')

    @LoginRequired()

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

        c.gist = Gist.get_or_404(gist_id)

        return rendered

    @LoginRequired()

    @jsonify

    def check_revision(self, gist_id):

        c.gist = Gist.get_or_404(gist_id)

from kallithea.config.routing import url

from kallithea.lib import helpers as h

from kallithea.lib import auth_modules

from kallithea.lib.base import BaseController, render

from kallithea.lib.utils2 import generate_api_key, safe_int

from kallithea.model.db import Repository, UserEmailMap, User, UserFollowing

    #         path_prefix='/admin', name_prefix='admin_')

    @LoginRequired()

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

        super(MyAccountController, self)._before(*args, **kwargs)

from kallithea.model.db import Notification

from kallithea.model.notification import NotificationModel

from kallithea.model.meta import Session

from kallithea.lib.base import BaseController, render

from kallithea.lib import helpers as h

from kallithea.lib.page import Page

    #         path_prefix='/_admin', name_prefix='_admin_')

    @LoginRequired()

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

        super(NotificationsController, self)._before(*args, **kwargs)

class RepoGroupsController(BaseController):

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

        super(RepoGroupsController, self)._before(*args, **kwargs)

    # file has a resource setup:

    #     map.resource('repo', 'repos')

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

        super(ReposController, self)._before(*args, **kwargs)

            force_defaults=False)

    @LoginRequired()

    def repo_creating(self, repo_name):

        c.repo = repo_name

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

        return render('admin/repos/repo_creating.html')

    @LoginRequired()

    @jsonify

    def repo_check(self, repo_name):

        c.repo = repo_name

    #     map.resource('setting', 'settings', controller='admin/settings',

    #         path_prefix='/admin', name_prefix='admin_')

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

        super(SettingsController, self)._before(*args, **kwargs)

class UserGroupsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

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

        super(UserGroupsController, self)._before(*args, **kwargs)

        c.available_permissions = config['available_permissions']

    ChangesetDoesNotExistError, EmptyRepositoryError

import kallithea.lib.helpers as h

from kallithea.lib.base import BaseRepoController, render, jsonify

from kallithea.lib.utils import action_logger

from kallithea.lib.compat import OrderedDict

        return self._index(revision, method='download')

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def comment(self, repo_name, revision):

        return data

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

from kallithea.config.routing import url

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

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int

        return render('/forks/forks.html')

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    @HasRepoPermissionLevelDecorator('read')

    def fork(self, repo_name):

            force_defaults=False)

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    @HasRepoPermissionLevelDecorator('read')

    def fork_create(self, repo_name):

    def about(self):

        return render('/about.html')

    def index(self):

        c.group = None

        return render('/index.html')

    @jsonify

    def repo_switcher_data(self):

        # wrapper for conditional cache

        }

        return data

    @jsonify

    def users_and_groups_data(self):

        """

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

import kallithea.lib.helpers as h

from kallithea.lib.base import BaseController, render

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int, AttributeDict

        return feed.writeString('utf-8')

    @LoginRequired()

    def index(self):

        # Return a rendered template

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

        return render('journal/journal.html')

    @LoginRequired(api_access=True)

    def journal_atom(self):

        """

        Produce an atom-1.0 feed via feedgenerator module

        return self._atom_feed(following, public=False)

    @LoginRequired(api_access=True)

    def journal_rss(self):

        """

        Produce an rss feed via feedgenerator module

        return self._rss_feed(following, public=False)

    @LoginRequired()

    def toggle_following(self):

        user_id = request.POST.get('follows_user_id')

        if user_id:

        raise HTTPBadRequest()

    def public_journal(self):

        # Return a rendered template

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

        return render('journal/public_journal.html')

    def public_journal_atom(self):

        """

        Produce an atom-1.0 feed via feedgenerator module

        return self._atom_feed(c.following)

    def public_journal_rss(self):

        """

        Produce an rss2 feed via feedgenerator module

from kallithea.config.routing import url

from kallithea.lib import helpers as h

from kallithea.lib import diffs

from kallithea.lib.base import BaseRepoController, render, jsonify

from kallithea.lib.page import Page

from kallithea.lib.utils import action_logger

        return render('/pullrequests/pullrequest_show_all.html')

    @LoginRequired()

    def show_my(self):

        c.closed = request.GET.get('closed') or ''

        return render('/pullrequests/pullrequest_show_my.html')

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    def index(self):

        org_repo = c.db_repo

        return render('/pullrequests/pullrequest.html')

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def repo_info(self, repo_name):

            }

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    def create(self, repo_name):

        repo = c.db_repo

    # pullrequest_post for PR editing

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    def post(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        raise HTTPFound(location=pull_request.url())

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def delete(self, repo_name, pull_request_id):

        return render('/pullrequests/pullrequest_show.html')

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def comment(self, repo_name, pull_request_id):

        return data

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

class SearchController(BaseRepoController):

    def index(self, repo_name=None):

        c.repo_name = repo_name

        c.formated_results = []

from kallithea.config.conf import ALL_READMES, ALL_EXTS, LANGUAGES_EXTENSIONS_MAP

from kallithea.model.db import Statistics, CacheInvalidation, User

from kallithea.lib.utils2 import safe_int, safe_str

from kallithea.lib.base import BaseRepoController, render, jsonify

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.markup_renderer import MarkupRenderer

        return render('summary/summary.html')

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    @jsonify

    def repo_size(self, repo_name):

# Use as decorator

class LoginRequired(object):

    Also checks that IP address is allowed, and if using API key instead

    of regular cookie authentication, checks that API key access is allowed

    (based on `api_access` parameter and the API view whitelist).

    """

        self.api_access = api_access

    def __call__(self, func):

        return decorator(self.__wrapper, func)

                raise HTTPForbidden()

        # regular user authentication

            log.info('user %s authenticated with regular auth @ %s', user, loc)

            return func(*fargs, **fkwargs)

        else:

            log.warning('user %s NOT authenticated with regular auth @ %s', user, loc)

# Use as decorator