# url('admin_settings_my_account')

        c.user = UserModel().get(c.rhodecode_user.user_id, cache=False)

        c.user_repos = ScmModel().get_repos(all_repos)

        if c.user.username == 'default':

from pylons import tmpl_context as c

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.utils import OrderedDict

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

        super(BranchesController, self).__before__()

    def index(self):

        c.repo_branches = OrderedDict()

        return render('branches/branches.html')

from pylons import request, session, tmpl_context as c

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from webhelpers.paginate import Page

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

        else:

            c.size = int(session.get('changelog_size', default))

        p = int(request.params.get('page', 1))

                            items_per_page=c.size)

        return render('changelog/changelog.html')

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.utils import EmptyChangeset

from vcs.exceptions import RepositoryError, ChangesetError, \

ChangesetDoesNotExistError

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

        rev_range = revision.split('...')[:2]

        range_limit = 50

        try:

            if len(rev_range) == 2:

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                                                       range_limit)

            else:

            c.cs_ranges = list(rev_ranges)

        method = request.GET.get('diff', 'show')

        try:

        except RepositoryError:

            log.error(traceback.format_exc())

            return redirect(url('home'))

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file') + '\n'

                else:

                    diff = differ.DiffProcessor(f_udiff).raw_diff()

                cs1 = None

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file')

                else:

                    diff = differ.DiffProcessor(f_udiff).raw_diff()

                cs1 = filenode_old.last_changeset.raw_id

import logging

from pylons.i18n.translation import _

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                         language=self.language,

                         ttl=self.ttl)

            feed.add_item(title=cs.message,

                          link=url('changeset_home', repo_name=repo_name,

                                   revision=cs.raw_id, qualified=True),

                         language=self.language,

                         ttl=self.ttl)

            feed.add_item(title=cs.message,

                          link=url('changeset_home', repo_name=repo_name,

                                   revision=cs.raw_id, qualified=True),

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

import logging

import rhodecode.lib.helpers as h

from pylons import request, response, session, tmpl_context as c, url

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.utils import EmptyChangeset

from vcs.backends import ARCHIVE_SPECS

from vcs.exceptions import RepositoryError, ChangesetError, \

from vcs.utils import diffs as differ

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

    def index(self, repo_name, revision, f_path):

        try:

            #reditect to given revision from form

            post_revision = request.POST.get('at_rev', None)

            if post_revision:

                redirect(url('files_home', repo_name=c.repo_name,

                             revision=post_revision, f_path=f_path))

            c.f_path = f_path

            cur_rev = c.changeset.revision

            #prev link

            try:

                c.url_prev = url('files_home', repo_name=c.repo_name,

                             revision=prev_rev, f_path=f_path)

                if c.branch:

                    c.url_prev += '?branch=%s' % c.branch

                c.url_prev = '#'

            #next link

            try:

                c.url_next = url('files_home', repo_name=c.repo_name,

                         revision=next_rev, f_path=f_path)

                if c.branch:

                    c.url_next += '?branch=%s' % c.branch

                c.url_next = '#'

            #files

            try:

                c.files_list = c.changeset.get_node(f_path)

            except RepositoryError, e:

                h.flash(str(e), category='warning')

                redirect(h.url('files_home', repo_name=repo_name, revision=revision))

        return render('files/files.html')

    def rawfile(self, repo_name, revision, f_path):

        response.content_type = file_node.mimetype

        response.content_disposition = 'attachment; filename=%s' \

                                                    % f_path.split('/')[-1]

        return file_node.content

    def raw(self, repo_name, revision, f_path):

        response.content_type = 'text/plain'

        return file_node.content

    def annotate(self, repo_name, revision, f_path):

        try:

        except RepositoryError, e:

            h.flash(str(e), category='warning')

        c.f_path = f_path

        return render('files/files_annotate.html')

                ext = ext_data[1]

        try:

            if dbrepo.enable_downloads is False:

                return _('downloads disabled')

            content_type = ARCHIVE_SPECS[fileformat][0]

        except ChangesetDoesNotExistError:

            return _('Unknown revision %s') % revision

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                node1 = c.changeset_1.get_node(f_path)

            else:

                c.changeset_1 = EmptyChangeset()

                node1 = FileNode('.', '', changeset=c.changeset_1)

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                node2 = c.changeset_2.get_node(f_path)

            else:

                c.changeset_2 = EmptyChangeset()

        return render('files/file_diff.html')

    def _get_history(self, repo, node, f_path):

        if not node.kind is NodeKind.FILE:

            return []

        changesets = node.history

        hist_l.append(changesets_group)

            #chs = chs.split(':')[-1]

            branches_group[0].append((chs, name),)

        hist_l.append(branches_group)

            #chs = chs.split(':')[-1]

            tags_group[0].append((chs, name),)

        hist_l.append(tags_group)

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

log = logging.getLogger(__name__)

        else:

            c.sort_by = current_sort

        c.sort_slug = current_sort_slug

        sort_key = current_sort_slug + '_sort'

        if c.sort_by.startswith('-'):

                                  reverse=True)

        else:

                                  reverse=False)

        return render('/index.html')

from sqlalchemy import or_

from sqlalchemy.orm import joinedload, make_transient

from webhelpers.paginate import Page

from paste.httpexceptions import HTTPInternalServerError

from rhodecode.lib.auth import LoginRequired, NotAnonymous

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.helpers import get_token

from rhodecode.model.db import UserLog, UserFollowing

log = logging.getLogger(__name__)

    def index(self):

        # Return a rendered template

        c.following = self.sa.query(UserFollowing)\

            .filter(UserFollowing.user_id == c.rhodecode_user.user_id)\

            .options(joinedload(UserFollowing.follows_repository))\

            filtering_criterion = UserLog.repository_id.in_(repo_ids)

        if not repo_ids and user_ids:

            filtering_criterion = UserLog.user_id.in_(user_ids)

        if filtering_criterion is not None:

            journal = self.sa.query(UserLog)\

                .options(joinedload(UserLog.user))\

                .order_by(UserLog.action_date.desc())

        else:

            journal = []

        c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager)

        c.journal_data = render('journal/journal_data.html')

        if request.params.get('partial'):

            return c.journal_data

        return render('journal/journal.html')

    def _get_daily_aggregate(self, journal):

        groups = []

        for k, g in groupby(journal, lambda x:x.action_as_day):

            user_group = []

        cur_token = request.POST.get('auth_token')

        token = get_token()

        if cur_token == token:

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

            if user_id:

                try:

                                                    c.rhodecode_user.user_id)

                    return 'ok'

                except:

            repo_id = request.POST.get('follows_repo_id')

            if repo_id:

                try:

                                                    c.rhodecode_user.user_id)

                    return 'ok'

                except:

import traceback

from pylons.i18n.translation import _

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

import traceback

import formencode

from pylons import tmpl_context as c, request, url

from pylons.controllers.util import redirect

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAllDecorator

from rhodecode.lib.utils import invalidate_cache, action_logger

from rhodecode.model.forms import RepoSettingsForm, RepoForkForm

from rhodecode.model.repo import RepoModel

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasRepoPermissionAllDecorator('repository.admin')

            defaults.update({'g_perm_%s' % p.users_group.users_group_name:

                             p.permission.permission_name})

            render('settings/repo_settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            c.repo_info = repo_model.get_by_repo_name(repo_name)

            c.users_array = repo_model.get_users_js()

            errors.value.update({'user':c.repo_info.user.username})

                render('settings/repo_settings.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

            c.new_repo = errors.value['fork_name']

            r = render('settings/repo_fork.html')

                r,

                defaults=errors.value,

                errors=errors.error_dict or {},

from webhelpers.paginate import Page

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

    def index(self):

        p = int(request.params.get('page', 1))

        c.shortlog_data = render('shortlog/shortlog_data.html')

        if request.params.get('partial'):

            return c.shortlog_data

from pylons import tmpl_context as c, request, url

from pylons.i18n.translation import _

from rhodecode.model.db import Statistics

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.utils import OrderedDict, EmptyChangeset

from rhodecode.lib.celerylib import run_task

    import simplejson as json

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

        super(SummaryController, self).__before__()

    def index(self):

        c.dbrepo = dbrepo

                                             c.rhodecode_user.user_id)

        def url_generator(**kw):

            return url('shortlog_home', repo_name=c.repo_name, **kw)

        branches_group = ([], _("Branches"))

        tags_group = ([], _("Tags"))

            #chs = chs.split(':')[-1]

            branches_group[0].append((chs, name),)

        download_l.append(branches_group)

            #chs = chs.split(':')[-1]

            tags_group[0].append((chs, name),)

        download_l.append(tags_group)

from pylons import tmpl_context as c

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.utils import OrderedDict

log = logging.getLogger(__name__)

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

        super(TagsController, self).__before__()

    def index(self):

        c.repo_tags = OrderedDict()

        return render('tags/tags.html')

        self.cut_off_limit = int(config.get('cut_off_limit'))

        self.sa = meta.Session()

        #c.unread_journal = scm_model.get_unread_journal()

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

            return WSGIController.__call__(self, environ, start_response)

        finally:

            meta.Session.remove()

        revs_top_limit = 50 #show upto this amount of changesets hidden

        revs = action_params.split(',')

        repo_name = user_log.repository.repo_name

        from rhodecode.model.scm import ScmModel

        message = lambda rev: get_changeset_safe(repo, rev).message

        cs_links = " " + ', '.join ([link_to(rev,

        return cs_links

    def get_fork_name():

        repo_name = action_params

    map = {'user_deleted_repo':(_('[deleted] repository'), None),

           'user_created_repo':(_('[created] repository'), None),

import traceback

from datetime import datetime

from vcs.utils.lazy import LazyProperty

from vcs.backends import get_backend

        repo = self.sa.query(Repository)\

            .options(joinedload(Repository.fork))\

            .options(joinedload(Repository.user))\

            .filter(Repository.repo_name == repo_name)\

        if cache:

            repo.invalidate()

        ret = repo.scalar()

        return ret

from mercurial import ui

from sqlalchemy.exc import DatabaseError

from beaker.cache import cache_region, region_invalidate

        and fill that backed with information from database

        :param all_repos: give specific repositories list, good for filtering