c.repo_groups = [('', '')]

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

                                    map(lambda k: k.group_name,

                                        k.parents + [k])

                                    )

                                )

        c.repo_groups.extend([(x.group_id, parents_link(x)) for \

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

        c.repo_groups = sorted(c.repo_groups,

                               key=lambda t: t[1].split('»')[0])

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

    def __load_data(self, group_id):

        """

        Load defaults settings for edit, and update

        :param group_id:

        """

        self.__load_defaults()

        repo_group = Group.get(group_id)

    @HasPermissionAnyDecorator('hg.admin')

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

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

        # url('repos_groups')

        sk = lambda g:g.parents[0].group_name if g.parents else g.group_name

        c.groups = sorted(Group.query().all(), key=sk)

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

    @HasPermissionAnyDecorator('hg.admin')

    def create(self):

        """POST /repos_groups: Create a new item"""

        # url('repos_groups')

        self.__load_defaults()

        repos_group_model = ReposGroupModel()

        repos_group_form = ReposGroupForm(available_groups=

                                          c.repo_groups_choices)()

        try:

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

            repos_group_model.create(form_result)

            h.flash(_('created repos group %s') \

                    % form_result['group_name'], category='success')

            #TODO: in futureaction_logger(, '', '', '', self.sa)

        self.__load_defaults()

        c.repos_group = Group.get(id)

        repos_group_model = ReposGroupModel()

        repos_group_form = ReposGroupForm(edit=True,

                                          old_data=c.repos_group.get_dict(),

                                          available_groups=

                                            c.repo_groups_choices)()

        try:

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

            repos_group_model.update(id, form_result)

            h.flash(_('updated repos group %s') \

                    % form_result['group_name'], category='success')

            #TODO: in futureaction_logger(, '', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

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

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('group_name'), category='error')

        return redirect(url('repos_groups'))

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

        repos_group_model = ReposGroupModel()

        gr = Group.get(id)

        repos = gr.repositories.all()

        if repos:

            h.flash(_('This group contains %s repositores and cannot be '

                      'deleted' % len(repos)),

                    category='error')

            return redirect(url('repos_groups'))

        #overwrite our cached list with current filter

        gr_filter = [r.repo_name for r in c.group_repos]

        c.cached_repo_list = self.scm_model.get_repos(all_repos=gr_filter)

        if c.sort_by.startswith('-'):

            c.repos_list = sorted(c.cached_repo_list, key=itemgetter(sort_key),

                                  reverse=True)

        else:

            c.repos_list = sorted(c.cached_repo_list, key=itemgetter(sort_key),

                                  reverse=False)

        c.repo_cnt = len(c.repos_list)

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

            .filter(Group.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)

        c.repos_group = Group.get(id)

        defaults = self.__load_data(id)

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @property

    def groups_with_parents(self):

        groups = []

        if self.group is None:

            return groups

        cur_gr = self.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 groups_and_repo(self):

        return self.groups_with_parents, self.just_name

class Group(Base):

    __tablename__ = 'groups'

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

    @classmethod

    def url_sep(cls):

        return '/'

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

        return Group.url_sep().join([g.group_name for g in self.parents] +

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

            if old_ugname != value or not edit:

                if UsersGroup.get_by_group_name(value, cache=False,

                                               case_insensitive=True):

                    raise formencode.Invalid(_('This users group '

                                               'already exists') , value,

                                             state)

            if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:

                raise formencode.Invalid(_('Group name may only contain '

                                           'alphanumeric characters '

                                           'underscores, periods or dashes '

                                           'and must begin with alphanumeric '

                                           'character'), value, state)

    return _ValidUsersGroup

def ValidReposGroup(edit, old_data):

    class _ValidReposGroup(formencode.validators.FancyValidator):

        def validate_python(self, value, state):

            #TODO WRITE VALIDATIONS

            group_name = value.get('group_name')

            # slugify repo group just in case :)

            slug = repo_name_slug(group_name)

            old_gname = None

            if edit:

                old_gname = Group.get(

                            old_data.get('group_id')).group_name

            if old_gname != group_name or not edit:

                # check filesystem

                gr = Group.query().filter(Group.group_name == slug)\

                    .filter(Group.group_parent_id == group_parent_id).scalar()

                if gr:

                    e_dict = {'group_name':_('This group already exists')}

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

                                             error_dict=e_dict)

    return _ValidReposGroup

class ValidPassword(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        if value:

            if value.get('password'):

    def __create_group(self, group_name, parent_id):

        """

        makes repositories group on filesystem

        :param repo_name:

        :param parent_id:

        """

        if parent_id:

            paths = Group.get(parent_id).full_path.split(Group.url_sep())

            parent_path = os.sep.join(paths)

        else:

            parent_path = ''

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

        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)

        """

        Renames a group on filesystem

        :param group_name:

        """

        if os.path.isdir(new_path):

        shutil.move(old_path, new_path)

    def __delete_group(self, group):

        """

        Deletes a group from a filesystem

        :param group: instance of group from database

        """

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

        paths = os.sep.join(paths)

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

        os.rmdir(rm_path)

    def create(self, form_data):

        try:

            new_repos_group = Group()

            new_repos_group.group_name = form_data['group_name']

            new_repos_group.group_description = \

                form_data['group_description']

            new_repos_group.group_parent_id = form_data['group_parent_id']

            self.sa.add(new_repos_group)

            self.__create_group(form_data['group_name'],

                                form_data['group_parent_id'])

            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)

            old_name = repos_group.group_name

            repos_group.group_name = form_data['group_name']

            repos_group.group_description = \

                form_data['group_description']

            repos_group.group_parent_id = form_data['group_parent_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:

            users_group = Group.get(users_group_id)

            self.sa.delete(users_group)

            self.__delete_group(users_group)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise