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

        m.connect("new_repos_group", "/repos_groups/new",

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

        m.connect("formatted_new_repos_group", "/repos_groups/new.{format}",

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

        m.connect("update_repos_group", "/repos_groups/{id}",

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

                                                   function=check_int))

        m.connect("delete_repos_group", "/repos_groups/{id}",

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

                                                   function=check_int))

        m.connect("edit_repos_group", "/repos_groups/{id}/edit",

        m.connect("formatted_edit_repos_group",

                  "/repos_groups/{id}.{format}/edit",

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

                                                 function=check_int))

        m.connect("repos_group", "/repos_groups/{id}",

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

                                                 function=check_int))

        m.connect("formatted_repos_group", "/repos_groups/{id}.{format}",

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

                                                 function=check_int))

        # ajax delete repos group perm user

        m.connect('delete_repos_group_user_perm',

        c.repo_cnt = 0

        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)

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

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

log = logging.getLogger(__name__)

class RepoModel(BaseModel):

    cls = Repository

    URL_SEPARATOR = Repository.url_sep()

    def __get_users_group(self, users_group):

        return self._get_instance(UsersGroup, users_group,

                                  callback=UsersGroup.get_by_group_name)

        return self._get_instance(RepoGroup, repos_group,

                                  callback=RepoGroup.get_by_group_name)

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

        return q.ui_value

        except:

            log.error(traceback.format_exc())

            raise

    def create_repo(self, repo_name, repo_type, description, owner,

                    private=False, clone_uri=None, repos_group=None,

                    landing_rev='tip', just_db=False, fork_of=None,

                    copy_fork_permissions=False):

        from rhodecode.model.scm import ScmModel

        owner = self._get_user(owner)

        fork_of = self._get_repo(fork_of)

        try:

            # repo name is just a name of repository

            # while repo_name_full is a full qualified name that is combined

            # with name and path of group

            repo_name_full = repo_name

            repo_name = repo_name.split(self.URL_SEPARATOR)[-1]

            new_repo = Repository()

            new_repo.enable_statistics = False

            new_repo.repo_name = repo_name_full

            new_repo.repo_type = repo_type

log = logging.getLogger(__name__)

class ReposGroupModel(BaseModel):

    cls = RepoGroup

    def __get_users_group(self, users_group):

        return self._get_instance(UsersGroup, users_group,

                                  callback=UsersGroup.get_by_group_name)

        return self._get_instance(RepoGroup, repos_group,

                                  callback=RepoGroup.get_by_group_name)

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

        q = RhodeCodeUi.get_by_key('/').one()

        return q.ui_value

        paths = group.full_path.split(RepoGroup.url_sep())

        paths = os.sep.join(paths)

        rm_path = os.path.join(self.repos_path, paths)

        if os.path.isdir(rm_path):

            # delete only if that path really exists

            os.rmdir(rm_path)

    def create(self, group_name, group_description, parent=None, just_db=False):

        try:

            new_repos_group = RepoGroup()

            new_repos_group.group_description = group_description

            new_repos_group.group_name = new_repos_group.get_new_name(group_name)

            self.sa.add(new_repos_group)

            self._create_default_perms(new_repos_group)

            if not just_db:

                # we need to flush here, in order to check if database won't

                # throw any exceptions, create filesystem dirs at the very end

                self.sa.flush()

                self.__create_group(new_repos_group.group_name)

            return new_repos_group

            for r in repos_group.repositories:

                r.repo_name = r.get_new_name(r.just_name)

                self.sa.add(r)

            self.__rename_group(old_path, new_path)

            return repos_group

        except:

            log.error(traceback.format_exc())

            raise

    def delete(self, repos_group):

        try:

            self.sa.delete(repos_group)

            self.__delete_group(repos_group)

        except:

            log.exception('Error removing repos_group %s' % repos_group)

            raise

    def grant_user_permission(self, repos_group, user, perm):

        """

        Grant permission for user on given repositories group, or update

        existing one if found

        :param repos_group: Instance of ReposGroup, repositories_group_id,

            or repositories_group name

        :param user: Instance of User, user_id or username

        :param perm: Instance of Permission, or permission_name

        """

        user = self._get_user(user)

        permission = self._get_perm(perm)

        # check if we have that permission already

        obj = self.sa.query(UserRepoGroupToPerm)\

            .filter(UserRepoGroupToPerm.user == user)\

            .filter(UserRepoGroupToPerm.group == repos_group)\

            .scalar()

        if obj is None:

            # create new !

            obj = UserRepoGroupToPerm()

        obj.group = repos_group

        obj.permission = permission

        self.sa.add(obj)

    def revoke_user_permission(self, repos_group, user):

        """

        Revoke permission for user on given repositories group

        :param repos_group: Instance of ReposGroup, repositories_group_id,

            or repositories_group name

        :param user: Instance of User, user_id or username

        """

        user = self._get_user(user)

        obj = self.sa.query(UserRepoGroupToPerm)\

            .filter(UserRepoGroupToPerm.user == user)\

            .filter(UserRepoGroupToPerm.group == repos_group)\

            .one()

        self.sa.delete(obj)

    def grant_users_group_permission(self, repos_group, group_name, perm):

        """

        Grant permission for users group on given repositories group, or update

        existing one if found

        :param repos_group: Instance of ReposGroup, repositories_group_id,

            or repositories_group name

        :param group_name: Instance of UserGroup, users_group_id,

            or users group name

        :param perm: Instance of Permission, or permission_name

        """

        group_name = self.__get_users_group(group_name)

        permission = self._get_perm(perm)

        # check if we have that permission already

        obj = self.sa.query(UsersGroupRepoGroupToPerm)\

            .filter(UsersGroupRepoGroupToPerm.group == repos_group)\

            .filter(UsersGroupRepoGroupToPerm.users_group == group_name)\

            .scalar()

        if obj is None:

            # create new

            obj = UsersGroupRepoGroupToPerm()

        obj.permission = permission

        self.sa.add(obj)

    def revoke_users_group_permission(self, repos_group, group_name):

        """

        Revoke permission for users group on given repositories group

        :param repos_group: Instance of ReposGroup, repositories_group_id,

            or repositories_group name

        :param group_name: Instance of UserGroup, users_group_id,

            or users group name

        """

        group_name = self.__get_users_group(group_name)

        obj = self.sa.query(UsersGroupRepoGroupToPerm)\

            .filter(UsersGroupRepoGroupToPerm.group == repos_group)\

            .filter(UsersGroupRepoGroupToPerm.users_group == group_name)\

            .one()

        self.sa.delete(obj)

    ## permissions overview

    <div id="perms" class="table">

           %for section in sorted(c.perm_user.permissions.keys()):

              <div class="perms_section_head">${section.replace("_"," ").capitalize()}</div>

              <div id='tbl_list_wrap_${section}' class="yui-skin-sam">

               <table id="tbl_list_${section}">

                <thead>

                    <tr>

                    <th class="left">${_('Name')}</th>

                    <th class="left">${_('Permission')}</th>

                </thead>

                <tbody>

                %for k in c.perm_user.permissions[section]:

                     <%

                     if section != 'global':

                         section_perm = c.perm_user.permissions[section].get(k)

                         _perm = section_perm.split('.')[-1]

                     else:

                         _perm = section_perm = None

                     %>

                    <tr>

                        <td>

                            %elif section == 'repositories_groups':

                                <a href="${h.url('repos_group_home',group_name=k)}">${k}</a>

                            %else:

                                ${h.get_permission_name(k)}

                            %endif

                        </td>

                        <td>

                            %if section == 'global':

                             ${h.bool2icon(k.split('.')[-1] != 'none')}

                            %else:

                             <span class="perm_tag ${_perm}">${section_perm}</span>

                            %endif

                    </tr>

                %endfor

                </tbody>

               </table>

              </div>

           %endfor

    </div>

</div>

<div class="box box-left">

    <!-- box / title -->

    <div class="title">

        <h5>${_('Email addresses')}</h5>