c.groups = self.sa.query(RepoGroup).order_by(RepoGroup.group_name)\

            .filter(RepoGroup.group_parent_id == id).all()

        return render('admin/repos_groups/repos_groups.html')

    @HasPermissionAnyDecorator('hg.admin')

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

        """GET /repos_groups/id/edit: Form to edit an existing item"""

        # url('edit_repos_group', id=ID)

        id_ = int(id)

        c.repos_group = RepoGroup.get(id_)

        defaults = self.__load_data(id_)

        # we need to exclude this group from the group list for editing

        c.repo_groups = filter(lambda x:x[0] != id_, c.repo_groups)

        return htmlfill.render(

            render('admin/repos_groups/repos_groups_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

                    self._req_id,

                    result=None,

                    error="Error encoding response"

                )

            )

    def _find_method(self):

        """

        Return method named by `self._req_method` in controller if able

        """

        log.debug('Trying to find JSON-RPC method: %s', self._req_method)

        if self._req_method.startswith('_'):

            raise AttributeError("Method not allowed")

        try:

            func = getattr(self, self._req_method, None)

        except UnicodeEncodeError:

            raise AttributeError("Problem decoding unicode in requested "

                                 "method name.")

        if isinstance(func, types.MethodType):

            return func

        else:

            raise AttributeError("No such method: %s" % self._req_method)

        try:

            rev_end = collection.index(collection[(-1 * offset)])

        except IndexError:

            rev_end = collection.index(collection[-1])

        rev_start = max(0, rev_end - revcount)

        data = []

        rev_end += 1

        if repo.alias == 'git':

            for _ in xrange(rev_start, rev_end):

                vtx = [0, 1]

                edges = [[0, 0, 1]]

                data.append(['', vtx, edges])

        elif repo.alias == 'hg':

            revs = list(reversed(xrange(rev_start, rev_end)))

            c.dag = graphmod.colored(graphmod.dagwalker(repo._repo, revs))

            for (id, type, ctx, vtx, edges) in c.dag:

                if type != graphmod.CHANGESET:

                    continue

                data.append(['', vtx, edges])

        c.jsdata = json.dumps(data)

            n_desc = 'r%s:%s' % (chs.revision, chs.short_id)

            changesets_group[0].append((chs.raw_id, n_desc,))

        hist_l.append(changesets_group)

        for name, chs in c.rhodecode_repo.branches.items():

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

        hist_l.append(branches_group)

        for name, chs in c.rhodecode_repo.tags.items():

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

        hist_l.append(tags_group)

        return hist_l

    @jsonify

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

                                   'repository.admin')

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

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

            cs = self.__get_cs_or_redirect(revision, repo_name)

            _d, _f = ScmModel().get_nodes(repo_name, cs.raw_id, f_path,

                                          flat=False)

            return _d + _f

        c.repos_list = self.scm_model.get_repos()

        c.groups = RepoGroup.query()\

            .filter(RepoGroup.group_parent_id == None).all()

        return render('/index.html')

    def repo_switcher(self):

        if request.is_xhr:

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

            c.repos_list = self.scm_model.get_repos(all_repos,

                                                    sort_key='name_sort')

            return render('/repo_switcher_list.html')

        else:

            return HTTPBadRequest()

    def branch_tag_switcher(self, repo_name):

        if request.is_xhr:

            c.rhodecode_db_repo = Repository.get_by_repo_name(c.repo_name)

            c.rhodecode_repo = c.rhodecode_db_repo.scm_instance

            return render('/switch_to_list.html')

        else:

            return HTTPBadRequest()

        inv = CacheInvalidation.invalidate(key)

        if inv is not None:

            region_invalidate(_get_readme_from_cache, None, key)

            CacheInvalidation.set_valid(inv.cache_key)

        return _get_readme_from_cache(key)

    def _get_download_links(self, repo):

        download_l = []

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

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

        for name, chs in c.rhodecode_repo.branches.items():

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

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

        download_l.append(branches_group)

        for name, chs in c.rhodecode_repo.tags.items():

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

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

        download_l.append(tags_group)

        return download_l

class HasPermissionAnyMiddleware(object):

    def __init__(self, *perms):

        self.required_perms = set(perms)

    def __call__(self, user, repo_name):

        usr = AuthUser(user.user_id)

        try:

            self.user_perms = set([usr.permissions['repositories'][repo_name]])

        except:

            self.user_perms = set()

        self.granted_for = ''

        self.username = user.username

        self.repo_name = repo_name

        return self.check_permissions()

    def check_permissions(self):

        log.debug('checking mercurial protocol '

                  'permissions %s for user:%s repository:%s', self.user_perms,

                                                self.username, self.repo_name)

        if self.required_perms.intersection(self.user_perms):

            log.debug('permission granted')

            return True

        log.debug('permission denied')

        return False

    Base class for controllers responsible for loading all needed data for

    repository loaded items are

    c.rhodecode_repo: instance of scm repository

    c.rhodecode_db_repo: instance of db

    c.repository_followers: number of followers

    c.repository_forks: number of forks

    """

    def __before__(self):

        super(BaseRepoController, self).__before__()

        if c.repo_name:

            c.rhodecode_db_repo = Repository.get_by_repo_name(c.repo_name)

            c.rhodecode_repo = c.rhodecode_db_repo.scm_instance

            if c.rhodecode_repo is None:

                log.error('%s this repository is present in database but it '

                          'cannot be created as an scm instance', c.repo_name)

                redirect(url('home'))

            c.repository_followers = self.scm_model.get_followers(c.repo_name)

            c.repository_forks = self.scm_model.get_forks(c.repo_name)

"""

   SQLAlchemy migrate provides two APIs :mod:`migrate.versioning` for

   database schema version and repository management and

   :mod:`migrate.changeset` that allows to define database schema changes

   using Python.

"""

from rhodecode.lib.dbmigrate.migrate.versioning import *

from rhodecode.lib.dbmigrate.migrate.changeset import *

                        if modelCol.name in dbTable.columns:

                            commonCols.append(modelCol.name)

                    commonColsStr = ', '.join(commonCols)

                    return 'INSERT INTO %s (%s) SELECT %s FROM %s' % \

                        (tableName, commonColsStr, commonColsStr, tempName)

                # Move the data in one transaction, so that we don't

                # leave the database in a nasty state.

                connection = self.engine.connect()

                trans = connection.begin()

                try:

                    connection.execute(

                        'CREATE TEMPORARY TABLE %s as SELECT * from %s' % \

                            (tempName, modelTable.name))

                    # make sure the drop takes place inside our

                    # transaction with the bind parameter

                    modelTable.drop(bind=connection)

                    modelTable.create(bind=connection)

                    connection.execute(getCopyStatement())

                    connection.execute('DROP TABLE %s' % tempName)

                    trans.commit()

                except:

                    trans.rollback()

                    raise

    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey(u'repositories.repo_id'), nullable=True, unique=None, default=None)

    follows_user_id = Column("follows_user_id", Integer(), ForeignKey(u'users.user_id'), nullable=True, unique=None, default=None)

    user = relation('User', primaryjoin='User.user_id==UserFollowing.user_id')

    follows_user = relation('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

    follows_repository = relation('Repository')

class CacheInvalidation(Base, BaseModel):

    __tablename__ = 'cache_invalidation'

    __table_args__ = (UniqueConstraint('cache_key'), {'useexisting':True})

    cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    cache_key = Column("cache_key", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    cache_args = Column("cache_args", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)

    def __init__(self, cache_key, cache_args=''):

        self.cache_key = cache_key

        self.cache_args = cache_args

        self.cache_active = False

    def __repr__(self):

            Session.commit()

        except Exception:

            log.error(traceback.format_exc())

            Session.rollback()

    @classmethod

    def set_valid(cls, key):

        """

        Mark this cache key as active and currently cached

        :param key:

        """

        inv_obj = Session.query(CacheInvalidation)\

            .filter(CacheInvalidation.cache_key == key).scalar()

        inv_obj.cache_active = True

        Session.add(inv_obj)

        Session.commit()

class DbMigrateVersion(Base, BaseModel):

    __tablename__ = 'db_migrate_version'

    __table_args__ = {'extend_existing':True}

    repository_id = Column('repository_id', String(250), primary_key=True)

    repository_path = Column('repository_path', Text)

    version = Column('version', Integer)

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

"""

    rhodecode.model.db

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

    Database Models for RhodeCode

    :created_on: Apr 08, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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

            docutils_settings.update({'input_encoding': 'unicode',

                                      'report_level':4})

            for k, v in docutils_settings.iteritems():

                directives.register_directive(k, v)

            parts = publish_parts(source=source,

                                  writer_name="html4css1",

                                  settings_overrides=docutils_settings)

            return parts['html_title'] + parts["fragment"]

        except ImportError:

            log.warning('Install docutils to use this function')

            return cls.plain(source)

    @classmethod

    def rst_with_mentions(cls, source):

        mention_pat = re.compile(r'(?:^@|\s@)(\w+)')

        def wrapp(match_obj):

            uname = match_obj.groups()[0]

            return ' **@%(uname)s** ' % {'uname':uname}

        mention_hl = mention_pat.sub(wrapp, source).strip()

        return cls.rst(mention_hl)

        also overwrites global settings with those takes from local hgrc file

        :param baseui: baseui instance

        :param extras: dict with extra params to put into baseui

        """

        hgrc = os.path.join(repo_path, '.hg', 'hgrc')

        # make our hgweb quiet so it doesn't print output

        baseui.setconfig('ui', 'quiet', 'true')

        #inject some additional parameters that will be available in ui

        #for hooks

        for k, v in extras.items():

            baseui.setconfig('rhodecode_extras', k, v)

        repoui = make_ui('file', hgrc, False)

        if repoui:

            #overwrite our ui instance with the section from hgrc file

            for section in ui_sections:

                for k, v in repoui.configitems(section):

                    baseui.setconfig(section, k, v)

        Adds an email address to the CC list. 

        :param recipient: email address of recipient.

        """

        self.cc.append(recipient)

    def add_bcc(self, recipient):

        """

        Adds an email address to the BCC list. 

        :param recipient: email address of recipient.

        """

        self.bcc.append(recipient)

    def attach(self, attachment):

        """

        Adds an attachment to the message.

        :param attachment: an **Attachment** instance.

        """

        self.attachments.append(attachment)

        # Decrement because we're going to lob off the first argument.

        # @@ This is hacky

        self.min_args -= 1

        self.bootstrap_config(args[0])

        self.update_parser()

        return super(BasePasterCommand, self).run(args[1:])

    def update_parser(self):

        """

        Abstract method.  Allows for the class's parser to be updated

        before the superclass's `run` method is called.  Necessary to

        allow options/arguments to be passed through to the underlying

        celery command.

        """

        raise NotImplementedError("Abstract Method.")

    def bootstrap_config(self, conf):

        """

        Loads the pylons configuration.

        """

        from pylons import config as pylonsconfig

        path_to_ini_file = os.path.realpath(conf)

        conf = paste.deploy.appconfig('config:' + path_to_ini_file)

class UserNotification(Base, BaseModel):

    __tablename__ = 'user_to_notification'

    __table_args__ = (UniqueConstraint('user_id', 'notification_id'),

                      {'extend_existing':True})

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), primary_key=True)

    notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

    read = Column('read', Boolean, default=False)

    sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

    user = relationship('User', lazy="joined")

    notification = relationship('Notification', lazy="joined",

                            order_by=lambda:Notification.created_on.desc(),)

    def mark_as_read(self):

        self.read = True

        Session.add(self)

class DbMigrateVersion(Base, BaseModel):

    __tablename__ = 'db_migrate_version'

    __table_args__ = {'extend_existing':True}

    repository_id = Column('repository_id', String(250), primary_key=True)

    repository_path = Column('repository_path', Text)

    version = Column('version', Integer)

        self._template_root = rhodecode.CONFIG['pylons.paths']['templates'][0]

        self._tmpl_lookup = rhodecode.CONFIG['pylons.app_globals'].mako_lookup

        self.email_types = {

            self.TYPE_CHANGESET_COMMENT:'email_templates/changeset_comment.html',

            self.TYPE_PASSWORD_RESET:'email_templates/password_reset.html',

            self.TYPE_REGISTRATION:'email_templates/registration.html',

            self.TYPE_DEFAULT:'email_templates/default.html'

        }

    def get_email_tmpl(self, type_, **kwargs):

        """

        return generated template for email based on given type

        :param type_:

        """

        base = self.email_types.get(type_, self.email_types[self.TYPE_DEFAULT])

        email_template = self._tmpl_lookup.get_template(base)

        # translator inject

        _kwargs = {'_':_}

        _kwargs.update(kwargs)

        log.debug('rendering tmpl %s with kwargs %s' % (base, _kwargs))

        return email_template.render(**_kwargs)

            raise Exception('Was trying to rename to already existing dir %s' \

            		     % new_path)

        shutil.move(old_path, new_path)

    def __delete_repo(self, repo):

        """

        removes repo from filesystem, the removal is acctually made by

        added rm__ prefix into dir, and rename internat .hg/.git dirs so this

        repository is no longer valid for rhodecode, can be undeleted later on

        by reverting the renames on this repository

        :param repo: repo object

        """

        rm_path = os.path.join(self.repos_path, repo.repo_name)

        log.info("Removing %s", rm_path)

        # disable hg/git

        alias = repo.repo_type

        shutil.move(os.path.join(rm_path, '.%s' % alias),

                    os.path.join(rm_path, 'rm__.%s' % alias))

        # disable repo

        shutil.move(rm_path, os.path.join(self.repos_path, 'rm__%s__%s' \

                                          % (datetime.today()\

                                             .strftime('%Y%m%d_%H%M%S_%f'),

                                            repo.repo_name)))

        else:

            p = UsersGroupRepoToPerm()

            p.users_group = users_group

            p.repository = repository

            p.permission = permission

            self.sa.add(p)

    def delete_users_group_permission(self, repository, users_group):

        current = self.get_users_group_permission(repository, users_group)

        if current:

            self.sa.delete(current)

    def update_or_delete_user_permission(self, repository, user, permission):

        if permission:

            self.update_user_permission(repository, user, permission)

        else:

            self.delete_user_permission(repository, user)

    def update_or_delete_users_group_permission(self, repository, user_group,

                                              permission):

        if permission:

            self.update_users_group_permission(repository, user_group,

                                               permission)

        else:

            .filter(UsersGroupToPerm.permission == perm).scalar() is not None

    def grant_perm(self, users_group, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class')

        users_group = self.__get_users_group(users_group)

        new = UsersGroupToPerm()

        new.users_group = users_group

        new.permission = perm

        self.sa.add(new)

    def revoke_perm(self, users_group, perm):

        if not isinstance(perm, Permission):

            raise Exception('perm needs to be an instance of Permission class')

        users_group = self.__get_users_group(users_group)

        obj = UsersGroupToPerm.query()\

            .filter(UsersGroupToPerm.users_group == users_group)\

            .filter(UsersGroupToPerm.permission == perm).one()

        self.sa.delete(obj)

    def log_user(self, username=TEST_USER_ADMIN_LOGIN,

                 password=TEST_USER_ADMIN_PASS):

        self._logged_username = username

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':username,

                                  'password':password})

        if 'invalid user name' in response.body:

            self.fail('could not login using %s %s' % (username, password))

        self.assertEqual(response.status, '302 Found')

        ses = response.session['rhodecode_user']

        self.assertEqual(ses.get('username'), username)

        response = response.follow()

        self.assertEqual(ses.get('is_authenticated'), True)

        return response.session['rhodecode_user']

    def _get_logged_user(self):

        return User.get_by_username(self._logged_username)

    def checkSessionFlash(self, response, msg):

        self.assertTrue('flash' in response.session)

        self.assertTrue(msg in response.session['flash'][0][1])

    def test_delete_browser_fakeout(self):

        response = self.app.post(url('users_group', id=1),

                                 params=dict(_method='delete'))

    def test_show(self):

        response = self.app.get(url('users_group', id=1))

    def test_show_as_xml(self):

        response = self.app.get(url('formatted_users_group', id=1, format='xml'))

    def test_edit(self):

        response = self.app.get(url('edit_users_group', id=1))

    def test_edit_as_xml(self):

        response = self.app.get(url('formatted_edit_users_group', id=1, format='xml'))

    def test_assign_members(self):

        pass

    def test_add_create_permission(self):

        pass

    def test_revoke_members(self):

        pass

from rhodecode.tests import *

class TestBranchesController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='branches',

                                    action='index', repo_name=HG_REPO))

        response.mustcontain("""<a href="/%s/files/27cd5cce30c96924232dffcd24178a07ffeb5dfc/">default</a>""" % HG_REPO)

        response.mustcontain("""<a href="/%s/files/97e8b885c04894463c51898e14387d80c30ed1ee/">git</a>""" % HG_REPO)

        response.mustcontain("""<a href="/%s/files/2e6a2bf9356ca56df08807f4ad86d480da72a8f4/">web</a>""" % HG_REPO)

        text = u'CommentOnRevision'

        params = {'text':text}

        response = self.app.post(url(controller='changeset', action='comment',

                                     repo_name=HG_REPO, revision=rev),

                                     params=params)

        comments = ChangesetComment.query().all()

        self.assertEqual(len(comments), 1)

        comment_id = comments[0].comment_id

        self.app.delete(url(controller='changeset',

                                    action='delete_comment',

                                    repo_name=HG_REPO,

                                    comment_id=comment_id))

        comments = ChangesetComment.query().all()

        self.assertEqual(len(comments), 0)

        response = self.app.get(url(controller='changeset', action='index',

                                repo_name=HG_REPO, revision=rev))

        self.assertTrue('''<div class="comments-number">0 comment(s)'''

                        ''' (0 inline)</div>''' in response.body)

        assert """Revision %r does not exist for this repository""" % (rev) in response.session['flash'][0][1], 'No flash message'

        assert """%s""" % (HG_REPO) in response.session['flash'][0][1], 'No flash message'

    def test_raw_wrong_f_path(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        f_path = 'vcs/ERRORnodes.py'

        response = self.app.get(url(controller='files', action='raw',

                                    repo_name=HG_REPO,

                                    revision=rev,

                                    f_path=f_path))

        assert "There is no file nor directory at the given path: %r at revision %r" % (f_path, rev[:12]) in response.session['flash'][0][1], 'No flash message'

    def test_ajaxed_files_list(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc' 

        response = self.app.get(url('files_nodelist_home',repo_name=HG_REPO,

                                    f_path='/',

                                    revision=rev),

                                extra_environ={'HTTP_X_PARTIAL_XHR':'1'},

                                )

        self.assertTrue("vcs/web/simplevcs/views/repository.py" in response.body)

from rhodecode.tests import *

class TestTagsController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='tags', action='index', repo_name=HG_REPO))

        response.mustcontain("""<a href="/%s/files/27cd5cce30c96924232dffcd24178a07ffeb5dfc/">tip</a>""" % HG_REPO)

        response.mustcontain("""<a href="/%s/files/fd4bdb5e9b2a29b4393a4ac6caef48c17ee1a200/">0.1.4</a>""" % HG_REPO)

        response.mustcontain("""<a href="/%s/files/17544fbfcd33ffb439e2b728b5d526b1ef30bfcf/">0.1.3</a>""" % HG_REPO)

        response.mustcontain("""<a href="/%s/files/a7e60bff65d57ac3a1a1ce3b12a70f8a9e8a7720/">0.1.2</a>""" % HG_REPO)

        response.mustcontain("""<a href="/%s/files/eb3a60fc964309c1a318b8dfe26aa2d1586c85ae/">0.1.1</a>""" % HG_REPO)

            ('Y', True),

            ('yeS', True),

            ('Y', True),

            ('TRUE', True),

            ('T', True),

            ('False', False),

            ('F', False),

            ('FALSE', False),

            ('0', False),

            ('-1', False),

            ('', False), ]

        for case in test_cases:

            self.assertEqual(str2bool(case[0]), case[1])

    def test_mention_extractor(self):

        from rhodecode.lib import extract_mentioned_users

        sample = ("@first hi there @marcink here's my email marcin@email.com "

                  "@lukaszb check it pls @ ttwelve @D[] @one@two@three "

                  "@MARCIN    @maRCiN @2one_more22")

        s = ['2one_more22', 'D', 'MARCIN', 'first', 'lukaszb',

             'maRCiN', 'marcink', 'one']

        self.assertEqual(s, extract_mentioned_users(sample))

        Session.commit()

    def test_add_perm(self):

        perm = Permission.query().all()[0]

        UserModel().grant_perm(self.u1, perm)

        Session.commit()

        self.assertEqual(UserModel().has_perm(self.u1, perm), True)

    def test_has_perm(self):

        perm = Permission.query().all()

        for p in perm:

            has_p = UserModel().has_perm(self.u1, p)

            self.assertEqual(False, has_p)

    def test_revoke_perm(self):

        perm = Permission.query().all()[0]

        UserModel().grant_perm(self.u1, perm)

        Session.commit()

        self.assertEqual(UserModel().has_perm(self.u1, perm), True)

        #revoke

        UserModel().revoke_perm(self.u1, perm)

        Session.commit()

        self.assertEqual(UserModel().has_perm(self.u1, perm),False)