# url('new_repos_group')

        self.__load_defaults()

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

    @HasPermissionAnyDecorator('hg.admin')

    def update(self, id):

        """PUT /repos_groups/id: Update an existing item"""

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

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

        # Or using helpers:

        #    h.form(url('repos_group', id=ID),

        #           method='put')

        # url('repos_group', id=ID)

    @HasPermissionAnyDecorator('hg.admin')

    def delete(self, id):

        """DELETE /repos_groups/id: 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('repos_group', id=ID),

        #           method='delete')

        # url('repos_group', id=ID)

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

        """GET /repos_groups/id: Show a specific item"""

        # url('repos_group', id=ID)

        c.group = Group.get(id)

        if c.group:

            c.group_repos = c.group.repositories.all()

        else:

            return redirect(url('repos_group'))

        sortables = ['name', 'description', 'last_change', 'tip', 'owner']

        current_sort = request.GET.get('sort', 'name')

        current_sort_slug = current_sort.replace('-', '')

        if current_sort_slug not in sortables:

            c.sort_by = 'name'

            current_sort_slug = c.sort_by

        else:

            c.sort_by = current_sort

        c.sort_slug = current_sort_slug

        sort_key = current_sort_slug + '_sort'

        #overwrite our cached list with current filter

        return self.groups_with_parents, self.just_name

class Group(Base):

    __tablename__ = 'groups'

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

    __mapper_args__ = {'order_by':'group_name'}

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

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

    group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

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

    parent_group = relationship('Group', remote_side=group_id)

    def __init__(self, group_name='', parent_group=None):

        self.group_name = group_name

        self.parent_group = parent_group

    def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__, self.group_id,

                                  self.group_name)

    @property

    def parents(self):

        groups = []

        if self.parent_group is None:

            return groups

        cur_gr = self.parent_group

        groups.insert(0, cur_gr)

        while 1:

            gr = getattr(cur_gr, 'parent_group', None)

            cur_gr = cur_gr.parent_group

            if gr is None:

                break

            groups.insert(0, gr)

        return groups

    @property

    def full_path(self):

                        [self.group_name])

    @property

    def repositories(self):

        return Session.query(Repository).filter(Repository.group == self)

class Permission(Base):

    __tablename__ = 'permissions'

    __table_args__ = {'useexisting':True}

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

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

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

    def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__,

                                  self.permission_id, self.permission_name)

    @classmethod

    def get_by_key(cls, key):

        return Session.query(cls).filter(cls.permission_name == key).scalar()

class RepoToPerm(Base):

    __tablename__ = 'repo_to_perm'

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

        try:

            self.user_db = User.query()\

                .filter(User.active == True)\

                .filter(User.username == value).one()

        except Exception:

            raise formencode.Invalid(_('This username is not valid'),

                                     value, state)

        return value

def ValidRepoName(edit, old_data):

    class _ValidRepoName(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            repo_name = value.get('repo_name')

            slug = repo_name_slug(repo_name)

            if slug in ['_admin', '']:

                e_dict = {'repo_name': _('This repository name is disallowed')}

                raise formencode.Invalid('', value, state, error_dict=e_dict)

            if value.get('repo_group'):

                gr = Group.get(value.get('repo_group'))

                group_path = gr.full_path

            else:

                group_path = ''

                repo_name_full = repo_name

            value['repo_name_full'] = repo_name_full

            if old_data.get('repo_name') != repo_name_full or not edit:

                if group_path != '':

                    if RepoModel().get_by_repo_name(repo_name_full,):

                        e_dict = {'repo_name':_('This repository already '

                                                'exists in group "%s"') %

                                  gr.group_name}

                        raise formencode.Invalid('', value, state,

                                                 error_dict=e_dict)

                else:

                    if RepoModel().get_by_repo_name(repo_name_full):

                        e_dict = {'repo_name':_('This repository '

                                                'already exists')}

                        raise formencode.Invalid('', value, state,

                                                 error_dict=e_dict)

            return value

log = logging.getLogger(__name__)

class ReposGroupModel(BaseModel):

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

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

        return q.ui_value

    def __create_group(self, group_name, parent_id):

        """

        makes repositories group on filesystem

        :param repo_name:

        :param parent_id:

        """

        if parent_id:

        else:

        log.debug('creating new group in %s', create_path)

        if os.path.isdir(create_path):

            raise Exception('That directory already exists !')

        os.makedirs(create_path)

    def __rename_group(self, group_name):

        """

        Renames a group on filesystem

        :param group_name:

        """

        pass

        """

        Deletes a group from a filesystem

        """

    def create(self, form_data):

        try:

            new_repos_group = Group()

            new_repos_group.group_name = form_data['repos_group_name']

            new_repos_group.group_description = \

                form_data['repos_group_description']

            new_repos_group.group_parent_id = form_data['repos_group_parent']

            self.sa.add(new_repos_group)

            self.__create_group(form_data['repos_group_name'],

                                form_data['repos_group_parent'])

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def update(self, repos_group_id, form_data):

        try:

            repos_group = Group.get(repos_group_id)

            self.sa.add(repos_group)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def delete(self, users_group_id):

        try:

            self.sa.delete(users_group)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise