.. _changelog:

=========

Changelog

=========

1.5.0 (**2012-12-12**)

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

news

++++

- new rewritten from scratch diff engine. 10x faster in edge cases. Handling

  of file renames, copies, change flags and binary files

- added lightweight dashboard option. ref #500. New version of dashboard

  page that doesn't use any VCS data and is super fast to render. Recommended

  for large amount of repositories.

- implements #648 write Script for updating last modification time for

  lightweight dashboard

- implemented compare engine for git repositories.

- LDAP failover, option to specify multiple servers

- added Errormator and Sentry support for monitoring RhodeCode

- implemented #628: Pass server URL to rc-extensions hooks

- new tooltip implementation - added lazy loading of changesets from journal

  pages. This can significantly improve speed of rendering the page

- implements #632,added branch/tag/bookmarks info into feeds

  added changeset link to body of message

- implemented #638 permissions overview to groups

- implements #636, lazy loading of history and authors to speed up source

  pages rendering

- implemented #647, option to pass list of default encoding used to 

  encode to/decode from unicode

- added caching layer into RSS/ATOM feeds.

- basic implementation of cherry picking changesets for pull request, ref #575

- implemented #661 Add option to include diff in RSS feed

- implemented file history page for showing detailed changelog for a given file

- implemented #663 Admin/permission: specify default repogroup perms

- implemented #379 defaults settings page for creation of repositories, locking

  statistics, downloads, repository type

- implemented #210 filtering of admin journal based on Whoosh Query language

- added parents/children links in changeset viewref #650

fixes

+++++

- fixed git version checker

- #586 patched basic auth handler to fix issues with git behind proxy

- #589 search urlgenerator didn't properly escape special characters

- fixed issue #614 Include repo name in delete confirmation dialog

- fixed #623: Lang meta-tag doesn't work with C#/C++

- fixes #612 Double quotes to Single quotes result in bad html in diff

- fixes #630 git statistics do too much work making them slow.

- fixes #625 Git-Tags are not displayed in Shortlog

- fix for issue #602, enforce str when setting mercurial UI object. 

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

"""

    rhodecode.__init__

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

    RhodeCode, a web based repository management based on pylons

    versioning implementation: http://www.python.org/dev/peps/pep-0386/

    :created_on: Apr 9, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :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, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

import sys

import platform

try:

    from rhodecode.lib import get_current_revision

    _rev = get_current_revision(quiet=True)

    if _rev and len(VERSION) > 3:

        VERSION += ('dev%s' % _rev[0],)

except ImportError:

    pass

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

               '.'.join(VERSION[3:]))

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

__author__ = 'Marcin Kuzminski'

__url__ = 'http://rhodecode.org'

PLATFORM_WIN = ('Windows')

PLATFORM_OTHERS = ('Linux', 'Darwin', 'FreeBSD', 'OpenBSD', 'SunOS') #depracated

is_windows = __platform__ in PLATFORM_WIN

is_unix = not is_windows

BACKENDS = {

    'hg': 'Mercurial repository',

    'git': 'Git repository',

}

CELERY_ON = False

CELERY_EAGER = False

# link to config for pylons

CONFIG = {}

# Linked module for extensions

EXTENSIONS = {}

from rhodecode.model.meta import Session

from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup,\

    RhodeCodeSetting

from rhodecode.model.forms import RepoForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from rhodecode.lib.compat import json

from sqlalchemy.sql.expression import func

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):

        c.repo_groups = RepoGroup.groups_choices(check_perms=True)

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

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

        choices, c.landing_revs = ScmModel().get_repo_landing_revs()

        c.landing_revs_choices = choices

    def __load_data(self, repo_name=None):

        """

        Load defaults settings for edit, and update

        :param repo_name:

        """

        self.__load_defaults()

        c.repo_info = db_repo = Repository.get_by_repo_name(repo_name)

        repo = db_repo.scm_instance

        if c.repo_info is None:

            return redirect(url('repos'))

        ##override defaults for exact repo info here git/hg etc

        choices, c.landing_revs = ScmModel().get_repo_landing_revs(c.repo_info)

        c.landing_revs_choices = choices

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

        c.in_public_journal = UserFollowing.query()\

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

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

        if c.repo_info.stats:

            # this is on what revision we ended up so we add +1 for count

            last_rev = c.repo_info.stats.stat_on_revision + 1

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() 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 = RepoModel()._get_defaults(repo_name)

        c.repos_list = [('', _('--REMOVE FORK--'))]

        c.repos_list += [(x.repo_id, x.repo_name) for x in

                    Repository.query().order_by(Repository.repo_name).all()

                    if x.repo_id != c.repo_info.repo_id]

        defaults['id_fork_of'] = db_repo.fork.repo_id if db_repo.fork else ''

        return defaults

    @HasPermissionAllDecorator('hg.admin')

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

        """GET /repos: All items in the collection"""

        # url('repos')

        c.repos_list = Repository.query()\

                        .order_by(func.lower(Repository.repo_name))\

                        .all()

        repos_data = []

        total_records = len(c.repos_list)

        changed_name = repo_name

        #override the choices with extracted revisions !

        choices, c.landing_revs = ScmModel().get_repo_landing_revs(repo_name)

        c.landing_revs_choices = choices

        _form = RepoForm(edit=True, old_data={'repo_name': repo_name},

                         repo_groups=c.repo_groups_choices,

                         landing_revs=c.landing_revs_choices)()

        try:

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

            repo = repo_model.update(repo_name, **form_result)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('Repository %s updated successfully') % repo_name,

                    category='success')

            changed_name = repo.repo_name

            action_logger(self.rhodecode_user, 'admin_updated_repo',

                              changed_name, self.ip_addr, self.sa)

            Session().commit()

        except formencode.Invalid, errors:

            defaults = self.__load_data(repo_name)

            defaults.update(errors.value)

            return htmlfill.render(

                render('admin/repos/repo_edit.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                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:

            return redirect(url('repos'))

        try:

            action_logger(self.rhodecode_user, 'admin_deleted_repo',

                              repo_name, self.ip_addr, self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

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

            Session().commit()

        except IntegrityError, e:

            if e.message.find('repositories_fork_id_fkey') != -1:

                log.error(traceback.format_exc())

                h.flash(_('Cannot delete %s it still contains attached '

                          'forks') % repo_name,

                        category='warning')

            else:

                log.error(traceback.format_exc())

                h.flash(_('An error occurred during '

                          'deletion of %s') % repo_name,

                        category='error')

        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'))

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete_perm_user(self, repo_name):

        """

        DELETE an existing repository permission user

        :param repo_name:

        """

        try:

            RepoModel().revoke_user_permission(repo=repo_name,

                                               user=request.POST['user_id'])

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

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

                    category='error')

            raise HTTPInternalServerError()

    @HasRepoPermissionAllDecorator('repository.admin')

    def delete_perm_users_group(self, repo_name):

        """

        DELETE an existing repository permission users group

import formencode

import traceback

from formencode import htmlfill

from pylons import tmpl_context as c, request, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

import rhodecode.lib.helpers as h

from rhodecode.lib.helpers import Page

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

    NotAnonymous, HasRepoPermissionAny, HasPermissionAllDecorator,\

    HasPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

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

from rhodecode.model.repo import RepoModel

from rhodecode.model.forms import RepoForkForm

from rhodecode.model.scm import ScmModel

from rhodecode.lib.utils2 import safe_int

log = logging.getLogger(__name__)

class ForksController(BaseRepoController):

    @LoginRequired()

    def __before__(self):

        super(ForksController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices(check_perms=True)

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

        choices, c.landing_revs = ScmModel().get_repo_landing_revs()

        c.landing_revs_choices = choices

    def __load_data(self, repo_name=None):

        """

        Load defaults settings for edit, and update

        :param repo_name:

        """

        self.__load_defaults()

        c.repo_info = db_repo = Repository.get_by_repo_name(repo_name)

        repo = db_repo.scm_instance

        if c.repo_info is None:

            return redirect(url('repos'))

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

        c.in_public_journal = UserFollowing.query()\

            .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+1

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() 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 = RepoModel()._get_defaults(repo_name)

        # add suffix to fork

        defaults['repo_name'] = '%s-fork' % defaults['repo_name']

        return defaults

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

                                   'repository.admin')

    def forks(self, repo_name):

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

        repo_id = c.rhodecode_db_repo.repo_id

        d = []

        for r in Repository.get_repo_forks(repo_id):

            if not HasRepoPermissionAny(

                'repository.read', 'repository.write', 'repository.admin'

            )(r.repo_name, 'get forks check'):

                continue

            d.append(r)

        c.forks_pager = Page(d, page=p, items_per_page=20)

        c.forks_data = render('/forks/forks_data.html')

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

            return c.forks_data

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

    @NotAnonymous()

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

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

                                   'repository.admin')

    def fork(self, repo_name):

        c.repo_info = Repository.get_by_repo_name(repo_name)

        if not c.repo_info:

            return redirect(url('home'))

        defaults = self.__load_data(repo_name)

        return htmlfill.render(

            render('forks/fork.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @NotAnonymous()

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

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

                                   'repository.admin')

    def fork_create(self, repo_name):

        self.__load_defaults()

        c.repo_info = Repository.get_by_repo_name(repo_name)

        _form = RepoForkForm(old_data={'repo_type': c.repo_info.repo_type},

                             repo_groups=c.repo_groups_choices,

                             landing_revs=c.landing_revs_choices)()

        form_result = {}

        try:

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

            # create fork is done sometimes async on celery, db transaction

            # management is handled there.

            RepoModel().create_fork(form_result, self.rhodecode_user.user_id)

            h.flash(_('forked %s repository as %s') \

                      % (repo_name, form_result['repo_name']),

                    category='success')

        except formencode.Invalid, errors:

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

            return htmlfill.render(

                render('forks/fork.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during repository forking %s') %

                    repo_name, category='error')

        return redirect(url('home'))

from rhodecode.model.repo import RepoModel

from rhodecode.model.comment import ChangesetCommentsModel

from rhodecode.model.changeset_status import ChangesetStatusModel

from rhodecode.model.forms import PullRequestForm

log = logging.getLogger(__name__)

class PullrequestsController(BaseRepoController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(PullrequestsController, self).__before__()

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def _get_repo_refs(self, repo):

        hist_l = []

        branches_group = ([('branch:%s:%s' % (k, v), k) for

                         k, v in repo.branches.iteritems()], _("Branches"))

        bookmarks_group = ([('book:%s:%s' % (k, v), k) for

                         k, v in repo.bookmarks.iteritems()], _("Bookmarks"))

        tags_group = ([('tag:%s:%s' % (k, v), k) for

                         k, v in repo.tags.iteritems()], _("Tags"))

        hist_l.append(bookmarks_group)

        hist_l.append(branches_group)

        hist_l.append(tags_group)

        return hist_l

    def _get_default_rev(self, repo):

        """

        Get's default revision to do compare on pull request

        :param repo:

        """

        repo = repo.scm_instance

        if 'default' in repo.branches:

            return 'default'

        else:

            #if repo doesn't have default branch return first found

            return repo.branches.keys()[0]

    def show_all(self, repo_name):

        c.pull_requests = PullRequestModel().get_all(repo_name)

        c.repo_name = repo_name

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

    @NotAnonymous()

    def index(self):

        org_repo = c.rhodecode_db_repo

        if org_repo.scm_instance.alias != 'hg':

            log.error('Review not available for GIT REPOS')

            raise HTTPNotFound

        try:

            org_repo.scm_instance.get_changeset()

        except EmptyRepositoryError, e:

            h.flash(h.literal(_('There are no changesets yet')),

                    category='warning')

            redirect(url('summary_home', repo_name=org_repo.repo_name))

        other_repos_info = {}

        c.org_refs = self._get_repo_refs(c.rhodecode_repo)

        c.org_repos = []

        c.other_repos = []

        c.org_repos.append((org_repo.repo_name, '%s/%s' % (

                                org_repo.user.username, c.repo_name))

                           )

        # add org repo to other so we can open pull request agains itself

        c.other_repos.extend(c.org_repos)

        c.default_pull_request = org_repo.repo_name  # repo name pre-selected

        c.default_pull_request_rev = self._get_default_rev(org_repo)  # revision pre-selected

        c.default_revs = self._get_repo_refs(org_repo.scm_instance)

        #add orginal repo

        other_repos_info[org_repo.repo_name] = {

            'gravatar': h.gravatar_url(org_repo.user.email, 24),

            'description': org_repo.description,

            'revs': h.select('other_ref', '', c.default_revs, class_='refs')

        }

        #gather forks and add to this list

        for fork in org_repo.forks:

            c.other_repos.append((fork.repo_name, '%s/%s' % (

                                    fork.user.username, fork.repo_name))

                                 )

            other_repos_info[fork.repo_name] = {

        c.cs_ranges = [org_repo.get_changeset(x) for x in pull_request.revisions]

        other_ref = ('rev', getattr(c.cs_ranges[0].parents[0]

                                  if c.cs_ranges[0].parents

                                  else EmptyChangeset(), 'raw_id'))

        c.statuses = org_repo.statuses([x.raw_id for x in c.cs_ranges])

        c.target_repo = c.repo_name

        # defines that we need hidden inputs with changesets

        c.as_form = request.GET.get('as_form', False)

        c.org_ref = org_ref[1]

        c.other_ref = other_ref[1]

        diff_limit = self.cut_off_limit if not fulldiff else None

        #we swap org/other ref since we run a simple diff on one repo

        _diff = diffs.differ(org_repo, other_ref, other_repo, org_ref)

        diff_processor = diffs.DiffProcessor(_diff or '', format='gitdiff',

                                             diff_limit=diff_limit)

        _parsed = diff_processor.prepare()

        c.limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            c.limited_diff = True

        c.files = []

        c.changes = {}

        c.lines_added = 0

        c.lines_deleted = 0

        for f in _parsed:

            st = f['stats']

            if st[0] != 'b':

                c.lines_added += st[0]

                c.lines_deleted += st[1]

            fid = h.FID('', f['filename'])

            c.files.append([fid, f['operation'], f['filename'], f['stats']])

            diff = diff_processor.as_html(enable_comments=enable_comments,

                                          parsed_lines=[f])

            c.changes[fid] = [f['operation'], f['filename'], diff]

    def show(self, repo_name, pull_request_id):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

        c.pull_request = PullRequest.get_or_404(pull_request_id)

        c.target_repo = c.pull_request.org_repo.repo_name

        cc_model = ChangesetCommentsModel()

        cs_model = ChangesetStatusModel()

        _cs_statuses = cs_model.get_statuses(c.pull_request.org_repo,

                                            pull_request=c.pull_request,

                                            with_revisions=True)

        cs_statuses = defaultdict(list)

        for st in _cs_statuses:

            cs_statuses[st.author.username] += [st]

        c.pull_request_reviewers = []

        c.pull_request_pending_reviewers = []

        for o in c.pull_request.reviewers:

            st = cs_statuses.get(o.user.username, None)

            if st:

                sorter = lambda k: k.version

                st = [(x, list(y)[0])

                      for x, y in (groupby(sorted(st, key=sorter), sorter))]

            else:

                c.pull_request_pending_reviewers.append(o.user)

            c.pull_request_reviewers.append([o.user, st])

        # pull_requests repo_name we opened it against

        # ie. other_repo must match

        if repo_name != c.pull_request.other_repo.repo_name:

            raise HTTPNotFound

        # load compare data into template context

        enable_comments = not c.pull_request.is_closed()

        self._load_compare_data(c.pull_request, enable_comments=enable_comments)

        # inline comments

        c.inline_cnt = 0

        c.inline_comments = cc_model.get_inline_comments(

                                c.rhodecode_db_repo.repo_id,

                                pull_request=pull_request_id)

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        # comments

        c.comments = cc_model.get_comments(c.rhodecode_db_repo.repo_id,

                                           pull_request=pull_request_id)

        try:

            cur_status = c.statuses[c.pull_request.revisions[0]][0]

        except:

            log.error(traceback.format_exc())

            cur_status = 'undefined'

        if c.pull_request.is_closed() and 0:

            c.current_changeset_status = cur_status

        else:

            # changeset(pull-request) status calulation based on reviewers

            c.current_changeset_status = cs_model.calculate_status(

                                            c.pull_request_reviewers,

                                         )

        c.changeset_statuses = ChangesetStatus.STATUSES

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

    @NotAnonymous()

    @jsonify

    def comment(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        status = request.POST.get('changeset_status')

        change_status = request.POST.get('change_changeset_status')

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

            text = text or (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

        comm = ChangesetCommentsModel().create(

            text=text,

            repo=c.rhodecode_db_repo.repo_id,

            user=c.rhodecode_user.user_id,

            pull_request=pull_request_id,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line'),

            status_change=(ChangesetStatus.get_status_lbl(status)

        )

        action_logger(self.rhodecode_user,

                      'user_commented_pull_request:%s' % pull_request_id,

                      c.rhodecode_db_repo, self.ip_addr, self.sa)

        Session().commit()

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

            return redirect(h.url('pullrequest_show', repo_name=repo_name,

                                  pull_request_id=pull_request_id))

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

        if comm:

            c.co = comm

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

        return data

    @NotAnonymous()

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get(comment_id)

        if co.pull_request.is_closed():

            #don't allow deleting comments on closed pull request

            raise HTTPForbidden()

        owner = lambda: co.author.user_id == c.rhodecode_user.user_id

        if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:

            ChangesetCommentsModel().delete(comment=co)

            Session().commit()

            return True

        else:

            raise HTTPForbidden()

from pylons import tmpl_context as c, request, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

import rhodecode.lib.helpers as h

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

    HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import invalidate_cache, action_logger

from rhodecode.model.forms import RepoSettingsForm

from rhodecode.model.repo import RepoModel

from rhodecode.model.db import RepoGroup, Repository

from rhodecode.model.meta import Session

from rhodecode.model.scm import ScmModel

log = logging.getLogger(__name__)

class SettingsController(BaseRepoController):

    @LoginRequired()

    def __before__(self):

        super(SettingsController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices(check_perms=True)

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