controller='summary',

    rmap.connect('repos_group_home', '/{group_name:.*}',

                controller='admin/repos_groups', action="show_by_name",

                conditions=dict(function=check_group))

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

        c.repo_groups.extend([(x.group_id, parents_link(x.full_path_splitted))

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

        data['group_name'] = repo_group.name

    def show_by_name(self, group_name):

        id_ = Group.get_by_group_name(group_name).group_id

        return self.show(id_)

    # last element is repo in nested groups structure

    groups = groups[:-1]

    for lvl, group_name in enumerate(groups):

        group_name = '/'.join(groups[:lvl] + [group_name])

        if id_:

            return Session.query(cls).get(id_)

    @classmethod

    def get_by_group_name(cls, group_name):

        return cls.query().filter(cls.group_name == group_name).scalar()

    def name(self):

        return self.group_name.split(Group.url_sep())[-1]

    @property

        return self.group_name

    @property

    def full_path_splitted(self):

        return self.group_name.split(Group.url_sep())

    def get_new_name(self, group_name):

        """

        returns new full group name based on parent and new name

        :param group_name:

        """

        path_prefix = self.parent_group.full_path_splitted if self.parent_group else []

        return Group.url_sep().join(path_prefix + [group_name])

    def __create_group(self, group_name):

        create_path = os.path.join(self.repos_path, group_name)

    def __rename_group(self, old, new):

        if old == new:

            log.debug('skipping group rename')

            return

        old_path = os.path.join(self.repos_path, old)

        new_path = os.path.join(self.repos_path, new)

            new_repos_group.group_description = form_data['group_description']

            new_repos_group.parent_group = Group.get(form_data['group_parent_id'])

            new_repos_group.group_name = new_repos_group.get_new_name(form_data['group_name'])

            self.__create_group(new_repos_group.group_name)

            return new_repos_group

            old_path = repos_group.full_path

            #change properties

            repos_group.group_description = form_data['group_description']

            repos_group.parent_group = Group.get(form_data['group_parent_id'])

            repos_group.group_name = repos_group.get_new_name(form_data['group_name'])

            new_path = repos_group.full_path

            self.__rename_group(old_path, new_path)

            return repos_group

.groups_breadcrumbs a {

	color: #fff;

}

.groups_breadcrumbs a:hover {

    color: #bfe3ff;

    text-decoration: none;

}

    <span class="groups_breadcrumbs">

        » ${h.link_to(c.group.parent_group.name,

        h.url('repos_group_home',group_name=c.group.parent_group.group_name))}

    » "${c.group.name}" ${_('with')}

    </span> 

    ${_('Edit repos group')} ${c.repos_group.name} - ${c.rhodecode_name}

    ${_('edit repos group')} "${c.repos_group.name}"

                          ${h.link_to(h.literal(' » '.join([g.name for g in gr.parents+[gr]])),url('edit_repos_group',id=gr.group_id))}

		                   ${h.submit('remove_%s' % gr.name,'delete',class_="delete_icon action_button",onclick="return confirm('"+_('Confirm to delete this group')+"');")}

                          ${h.link_to(gr.name,url('repos_group_home',group_name=gr.group_name))}

import os

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.db import Group

from sqlalchemy.exc import IntegrityError

class TestReposGroups(unittest.TestCase):

    def setUp(self):

        self.g1 = self.__make_group('test1', skip_if_exists=True)

        self.g2 = self.__make_group('test2', skip_if_exists=True)

        self.g3 = self.__make_group('test3', skip_if_exists=True)

    def tearDown(self):

        print 'out'

    def __check_path(self, *path):

        path = [TESTS_TMP_PATH] + list(path)

        path = os.path.join(*path)

        return os.path.isdir(path)

    def _check_folders(self):

        print os.listdir(TESTS_TMP_PATH)

    def __make_group(self, path, desc='desc', parent_id=None,

                     skip_if_exists=False):

        gr = Group.get_by_group_name(path)

        if gr and skip_if_exists:

            return gr

        form_data = dict(group_name=path,

                         group_description=desc,

                         group_parent_id=parent_id)

        gr = ReposGroupModel().create(form_data)

        return gr

    def __delete_group(self, id_):

        ReposGroupModel().delete(id_)

    def __update_group(self, id_, path, desc='desc', parent_id=None):

        form_data = dict(group_name=path,

                         group_description=desc,

                         group_parent_id=parent_id)

        gr = ReposGroupModel().update(id_, form_data)

        return gr

    def test_create_group(self):

        g = self.__make_group('newGroup')

        self.assertEqual(g.full_path, 'newGroup')

        self.assertTrue(self.__check_path('newGroup'))

    def test_create_same_name_group(self):

        self.assertRaises(IntegrityError, lambda:self.__make_group('newGroup'))

    def test_same_subgroup(self):

        sg1 = self.__make_group('sub1', parent_id=self.g1.group_id)

        self.assertEqual(sg1.parent_group, self.g1)

        self.assertEqual(sg1.full_path, 'test1/sub1')

        self.assertTrue(self.__check_path('test1', 'sub1'))

        ssg1 = self.__make_group('subsub1', parent_id=sg1.group_id)

        self.assertEqual(ssg1.parent_group, sg1)

        self.assertEqual(ssg1.full_path, 'test1/sub1/subsub1')

        self.assertTrue(self.__check_path('test1', 'sub1', 'subsub1'))

    def test_remove_group(self):

        sg1 = self.__make_group('deleteme')

        self.__delete_group(sg1.group_id)

        self.assertEqual(Group.get(sg1.group_id), None)

        self.assertFalse(self.__check_path('deteteme'))

        sg1 = self.__make_group('deleteme', parent_id=self.g1.group_id)

        self.__delete_group(sg1.group_id)

        self.assertEqual(Group.get(sg1.group_id), None)

        self.assertFalse(self.__check_path('test1', 'deteteme'))

    def test_rename_single_group(self):

        sg1 = self.__make_group('initial')

        new_sg1 = self.__update_group(sg1.group_id, 'after')

        self.assertTrue(self.__check_path('after'))

        self.assertEqual(Group.get_by_group_name('initial'), None)

    def test_update_group_parent(self):

        sg1 = self.__make_group('initial', parent_id=self.g1.group_id)

        new_sg1 = self.__update_group(sg1.group_id, 'after', parent_id=self.g1.group_id)

        self.assertTrue(self.__check_path('test1', 'after'))

        self.assertEqual(Group.get_by_group_name('test1/initial'), None)

        new_sg1 = self.__update_group(sg1.group_id, 'after', parent_id=self.g3.group_id)

        self.assertTrue(self.__check_path('test3', 'after'))

        self.assertEqual(Group.get_by_group_name('test3/initial'), None)

        new_sg1 = self.__update_group(sg1.group_id, 'hello')

        self.assertTrue(self.__check_path('hello'))

        self.assertEqual(Group.get_by_group_name('hello'), new_sg1)