'setuptools-0.6c7-py2.5.egg': '45d2ad28f9750e7434111fde831e8372',

    'setuptools-0.6c8-py2.3.egg': '50759d29b349db8cfd807ba8303f1902',

    'setuptools-0.6c8-py2.4.egg': 'cba38d74f7d483c06e9daa6070cce6de',

    'setuptools-0.6c8-py2.5.egg': '1721747ee329dc150590a58b3e1ac95b',

    'setuptools-0.6c9-py2.3.egg': 'a83c4020414807b496e4cfbe08507c03',

    'setuptools-0.6c9-py2.4.egg': '260a2be2e5388d66bdaee06abec6342a',

    'setuptools-0.6c9-py2.5.egg': 'fe67c3e5a17b12c0e7c541b7ea43a8e6',

    'setuptools-0.6c9-py2.6.egg': 'ca37b1ff16fa2ede6e19383e7b59245a',

}

import sys, os

try: from hashlib import md5

except ImportError: from md5 import md5

def _validate_md5(egg_name, data):

    if egg_name in md5_data:

        digest = md5(data).hexdigest()

        if digest != md5_data[egg_name]:

            print >>sys.stderr, (

                "md5 validation of %s failed!  (Possible download problem?)"

                % egg_name

            )

            sys.exit(2)

    return data

def use_setuptools(

    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,

    download_delay=15

):

    """Automatically find/download setuptools and make it available on sys.path

    `version` should be a valid setuptools version number that is available

    as an egg for download under the `download_base` URL (which should end with

    a '/').  `to_dir` is the directory where setuptools will be downloaded, if

    it is not already available.  If `download_delay` is specified, it should

    be the number of seconds that will be paused before initiating a download,

    should one be required.  If an older version of setuptools is installed,

    this routine will print a message to ``sys.stderr`` and raise SystemExit in

    an attempt to abort the calling script.

    """

    was_imported = 'pkg_resources' in sys.modules or 'setuptools' in sys.modules

    def do_download():

        egg = download_setuptools(version, download_base, to_dir, download_delay)

        sys.path.insert(0, egg)

        import setuptools; setuptools.bootstrap_install_from = egg

    try:

        import pkg_resources

    except ImportError:

    try:

        pkg_resources.require("setuptools>="+version); return

    except pkg_resources.VersionConflict, e:

        if was_imported:

            print >>sys.stderr, (

            "The required version of setuptools (>=%s) is not available, and\n"

            "can't be installed while this script is running. Please install\n"

            " a more recent version first, using 'easy_install -U setuptools'."

            "\n\n(Currently using %r)"

            ) % (version, e.args[0])

            sys.exit(2)

        else:

            del pkg_resources, sys.modules['pkg_resources']    # reload ok

            return do_download()

    except pkg_resources.DistributionNotFound:

        return do_download()

def download_setuptools(

    version=DEFAULT_VERSION, download_base=DEFAULT_URL, to_dir=os.curdir,

    delay = 15

):

    """Download setuptools from a specified location and return its filename

    `version` should be a valid setuptools version number that is available

    as an egg for download under the `download_base` URL (which should end

    with a '/'). `to_dir` is the directory where the egg will be downloaded.

    `delay` is the number of seconds to pause before an actual download attempt.

    """

    import urllib2, shutil

    egg_name = "setuptools-%s-py%s.egg" % (version,sys.version[:3])

    url = download_base + egg_name

    saveto = os.path.join(to_dir, egg_name)

    src = dst = None

    if not os.path.exists(saveto):  # Avoid repeated downloads

        try:

            from distutils import log

            if delay:

                log.warn("""

---------------------------------------------------------------------------

This script requires setuptools version %s to run (even to display

help).  I will attempt to download it for you (from

%s), but

you may need to enable firewall access for this script first.

I will start the download in %d seconds.

(Note: if this machine does not have network access, please obtain the file

   %s

            from setuptools.command.easy_install import main

        except ImportError:

            from easy_install import main

        main(list(argv)+[download_setuptools(delay=0)])

        sys.exit(0) # try to force an exit

    else:

        if argv:

            from setuptools.command.easy_install import main

            main(argv)

        else:

            print "Setuptools version",version,"or greater has been installed."

            print '(Run "ez_setup.py -U setuptools" to reinstall or upgrade.)'

def update_md5(filenames):

    """Update our built-in md5 registry"""

    import re

    for name in filenames:

        base = os.path.basename(name)

        f = open(name,'rb')

        md5_data[base] = md5(f.read()).hexdigest()

        f.close()

    data = ["    %r: %r,\n" % it for it in md5_data.items()]

    data.sort()

    repl = "".join(data)

    import inspect

    srcfile = inspect.getsourcefile(sys.modules[__name__])

    f = open(srcfile, 'rb'); src = f.read(); f.close()

    match = re.search("\nmd5_data = {\n([^}]+)}", src)

    if not match:

        print >>sys.stderr, "Internal error!"

        sys.exit(2)

    src = src[:match.start(1)] + repl + src[match.end(1):]

    f = open(srcfile,'w')

    f.write(src)

    f.close()

if __name__=='__main__':

    if len(sys.argv)>2 and sys.argv[1]=='--md5update':

        update_md5(sys.argv[2:])

    else:

        main(sys.argv[1:])

# -*- coding: utf-8 -*-

"""

    rhodecode.__init__

    ~~~~~~~~~~~~~~~~~~

    RhodeCode, a web based repository management based on pylons

    versioning implementation: http://semver.org/

    :created_on: Apr 9, 2010

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 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 General Public License

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

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

# MA  02110-1301, USA.

import platform

VERSION = (1, 2, 0, 'beta')

__version__ = '.'.join((str(each) for each in VERSION[:4]))

__dbversion__ = 3 #defines current db version for migrations

__platform__ = platform.system()

PLATFORM_WIN = ('Windows',)

PLATFORM_OTHERS = ('Linux', 'Darwin', 'FreeBSD',)

try:

    from rhodecode.lib.utils import get_current_revision

    _rev = get_current_revision()

except ImportError:

    #this is needed when doing some setup.py operations

    _rev = False

if len(VERSION) > 3 and _rev:

    __version__ += ' [rev:%s]' % _rev[0]

def get_version():

    """Returns shorter version (digit parts only) as string."""

    return '.'.join((str(each) for each in VERSION[:3]))

BACKENDS = {

    'hg': 'Mercurial repository',

    #'git': 'Git repository',

}

    ``app_conf``

        The application's local configuration. Normally specified in

        the [app:<name>] section of the Paste ini file (where <name>

        defaults to main).

    """

    # Configure the Pylons environment

    config = load_environment(global_conf, app_conf)

    # The Pylons WSGI app

    app = PylonsApp(config=config)

    # Routing/Session/Cache Middleware

    app = RoutesMiddleware(app, config['routes.map'])

    app = SessionMiddleware(app, config)

    # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)

    app = SimpleHg(app, config)

    app = SimpleGit(app, config)

    if asbool(full_stack):

        # Handle Python exceptions

        app = ErrorHandler(app, global_conf, **config['pylons.errorware'])

        # Display error documents for 401, 403, 404 status codes (and

        # 500 when debug is disabled)

        if asbool(config['debug']):

            app = StatusCodeRedirect(app)

        else:

            app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])

    #enable https redirets based on HTTP_X_URL_SCHEME set by proxy

    app = HttpsFixup(app, config)

    # Establish the Registry for this application

    app = RegistryManager(app)

    if asbool(static_files):

        # Serve static files

        static_app = StaticURLParser(config['pylons.paths']['static_files'])

        app = Cascade([static_app, app])

        app = make_gzip_middleware(app, global_conf, compress_level=1)

    app.config = config

    return app

"""

Routes configuration

The more specific and detailed routes should be defined first so they

may take precedent over the more generic routes. For more information

refer to the routes manual at http://routes.groovie.org/docs/

"""

from __future__ import with_statement

from routes import Mapper

from rhodecode.lib.utils import check_repo_fast as cr

def make_map(config):

    """Create, configure and return the routes Mapper"""

    routes_map = Mapper(directory=config['pylons.paths']['controllers'],

                 always_scan=config['debug'])

    routes_map.minimization = False

    routes_map.explicit = False

    def check_repo(environ, match_dict):

        """

        check for valid repository for proper 404 handling

        :param environ:

        :param match_dict:

        """

        repo_name = match_dict.get('repo_name')

        return not cr(repo_name, config['base_path'])

    # The ErrorController route (handles 404/500 error pages); it should

    # likely stay at the top, ensuring it can always be resolved

    routes_map.connect('/error/{action}', controller='error')

    routes_map.connect('/error/{action}/{id}', controller='error')

    #==========================================================================

    # CUSTOM ROUTES HERE

    #==========================================================================

    #MAIN PAGE

    routes_map.connect('home', '/', controller='home', action='index')

    routes_map.connect('repo_switcher', '/repos', controller='home', action='repo_switcher')

    routes_map.connect('bugtracker', "http://bitbucket.org/marcinkuzminski/rhodecode/issues", _static=True)

    routes_map.connect('gpl_license', "http://www.gnu.org/licenses/gpl.html", _static=True)

    routes_map.connect('rhodecode_official', "http://rhodecode.org", _static=True)

    #ADMIN REPOSITORY REST ROUTES

    with routes_map.submapper(path_prefix='/_admin', controller='admin/repos') as m:

        m.connect("repos", "/repos",

             action="create", conditions=dict(method=["POST"]))

        m.connect("repos", "/repos",

             action="index", conditions=dict(method=["GET"]))

        m.connect("formatted_repos", "/repos.{format}",

             action="index",

            conditions=dict(method=["GET"]))

        m.connect("new_repo", "/repos/new",

             action="new", conditions=dict(method=["GET"]))

        m.connect("formatted_new_repo", "/repos/new.{format}",

             action="new", conditions=dict(method=["GET"]))

        m.connect("/repos/{repo_name:.*}",

             action="update", conditions=dict(method=["PUT"],

                                              function=check_repo))

        m.connect("/repos/{repo_name:.*}",

             action="delete", conditions=dict(method=["DELETE"],

                                              function=check_repo))

        m.connect("edit_repo", "/repos/{repo_name:.*}/edit",

             action="edit", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("formatted_edit_repo", "/repos/{repo_name:.*}.{format}/edit",

             action="edit", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("repo", "/repos/{repo_name:.*}",

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.admin.admin

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Controller for Admin panel of Rhodecode

    :created_on: Apr 7, 2010

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 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 General Public License

# 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

from pylons import request, tmpl_context as c

from sqlalchemy.orm import joinedload

from webhelpers.paginate import Page

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import UserLog

log = logging.getLogger(__name__)

class AdminController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(AdminController, self).__before__()

    @HasPermissionAllDecorator('hg.admin')

    def index(self):

        users_log = self.sa.query(UserLog)\

                .options(joinedload(UserLog.user))\

                .options(joinedload(UserLog.repository))\

                .order_by(UserLog.action_date.desc())

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

        c.users_log = Page(users_log, page=p, items_per_page=10)

        c.log_data = render('admin/admin_log.html')

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

            return c.log_data

        return render('admin/admin.html')

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.admin.ldap_settings

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    ldap controller for RhodeCode

    :created_on: Nov 26, 2010

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 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 General Public License

# 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 formencode

import traceback

from formencode import htmlfill

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

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib.base import BaseController, render

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.auth_ldap import LdapImportError

from rhodecode.model.settings import SettingsModel

from rhodecode.model.forms import LdapSettingsForm

from sqlalchemy.exc import DatabaseError

log = logging.getLogger(__name__)

class LdapSettingsController(BaseController):

    search_scope_choices = [('BASE',     _('BASE'),),

                            ('ONELEVEL', _('ONELEVEL'),),

                            ('SUBTREE',  _('SUBTREE'),),

                            ]

    search_scope_default = 'SUBTREE'

    tls_reqcert_choices = [('NEVER',  _('NEVER'),),

                           ('ALLOW',  _('ALLOW'),),

                           ('TRY',    _('TRY'),),

                           ('DEMAND', _('DEMAND'),),

                           ('HARD',   _('HARD'),),

                           ]

    tls_reqcert_default = 'DEMAND'

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        c.search_scope_choices = self.search_scope_choices

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.admin.permissions

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    permissions controller for Rhodecode

    :created_on: Apr 27, 2010

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 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 General Public License

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

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

# MA  02110-1301, USA.

from formencode import htmlfill

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

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.auth_ldap import LdapImportError

from rhodecode.lib.base import BaseController, render

from rhodecode.model.forms import LdapSettingsForm, DefaultPermissionsForm

from rhodecode.model.permission import PermissionModel

from rhodecode.model.settings import SettingsModel

from rhodecode.model.user import UserModel

import formencode

import logging

import traceback

log = logging.getLogger(__name__)

class PermissionsController(BaseController):

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

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('permission', 'permissions')

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(PermissionsController, self).__before__()

        self.perms_choices = [('repository.none', _('None'),),

                              ('repository.read', _('Read'),),

                              ('repository.write', _('Write'),),

                              ('repository.admin', _('Admin'),)]

        self.register_choices = [

            ('hg.register.none',

                _('disabled')),

            ('hg.register.manual_activate',

                _('allowed with manual account activation')),

            ('hg.register.auto_activate',

                _('allowed with automatic account activation')), ]

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.admin.repos

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Admin controller for RhodeCode

    :created_on: Apr 7, 2010

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 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 General Public License

# 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 traceback

import formencode

from operator import itemgetter

from formencode import htmlfill

from paste.httpexceptions import HTTPInternalServerError

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

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug

from rhodecode.lib.helpers import get_token

from rhodecode.model.db import User, Repository, UserFollowing, Group

from rhodecode.model.forms import RepoForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

log = logging.getLogger(__name__)

class ReposController(BaseController):

    """

    REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

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

    @LoginRequired()

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

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(ReposController, self).__before__()

    def __load_defaults(self):

        repo_model = RepoModel()

        c.repo_groups = [('', '')]

        parents_link = lambda k:h.literal('»'.join(

                                    map(lambda k:k.group_name,

                                        k.parents + [k])

                                    )

                                )

        c.repo_groups.extend([(x.group_id, parents_link(x)) for \

                                            x in self.sa.query(Group).all()])

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def __load_data(self, repo_name=None):

        """

        Load defaults settings for edit, and update

        :param repo_name:

        """

        self.__load_defaults()

        repo, dbrepo = ScmModel().get(repo_name, retval='repo')

        repo_model = RepoModel()

        c.repo_info = repo_model.get_by_repo_name(repo_name)

        if c.repo_info is None:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        c.default_user_id = User.by_username('default').user_id

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

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

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        if c.repo_info.stats:

            last_rev = c.repo_info.stats.stat_on_revision

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() - 1 if repo.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        defaults = c.repo_info.get_dict()

        group, repo_name = c.repo_info.groups_and_repo

        defaults['repo_name'] = repo_name

        defaults['repo_group'] = getattr(group[-1] if group else None,

                                         'group_id', None)

        #fill owner

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('edit_repo', repo_name=changed_name))

    @HasPermissionAllDecorator('hg.admin')

    def delete(self, repo_name):

        """

        DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='delete')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was moved or renamed  from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        try:

            action_logger(self.rhodecode_user, 'admin_deleted_repo',

                              repo_name, '', self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('deleted repository %s') % repo_name, category='success')

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

    def delete_perm_user(self, repo_name):

        """

        DELETE an existing repository permission user

        :param repo_name:

        """

        try:

            repo_model = RepoModel()

            repo_model.delete_perm_user(request.POST, repo_name)

        except Exception, e:

            h.flash(_('An error occurred during deletion of repository user'),

                    category='error')

            raise HTTPInternalServerError()

    @HasPermissionAllDecorator('hg.admin')

    def delete_perm_users_group(self, repo_name):

        """

        DELETE an existing repository permission users group

        :param repo_name:

        """

        try:

            repo_model = RepoModel()

            repo_model.delete_perm_users_group(request.POST, repo_name)

        except Exception, e:

            h.flash(_('An error occurred during deletion of repository'

                      ' users groups'),

                    category='error')

            raise HTTPInternalServerError()

    @HasPermissionAllDecorator('hg.admin')

    def repo_stats(self, repo_name):

        """

        DELETE an existing repository statistics

        :param repo_name:

        """

        try:

            repo_model = RepoModel()

            repo_model.delete_stats(repo_name)

        except Exception, e:

            h.flash(_('An error occurred during deletion of repository stats'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def repo_cache(self, repo_name):

        """

        INVALIDATE existing repository cache

        :param repo_name:

        """

        try:

            ScmModel().mark_for_invalidation(repo_name)

        except Exception, e:

            h.flash(_('An error occurred during cache invalidation'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def repo_public_journal(self, repo_name):

        """

        Set's this repository to be visible in public journal,

        in other words assing default user to follow this repo

        :param repo_name:

        """