repo_group_form = RepoGroupForm(repo_groups=c.repo_groups)

        try:

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

            gr = RepoGroupModel().create(

                group_name=form_result['group_name'],

                group_description=form_result['group_description'],

                owner=self.authuser.user_id, # TODO: make editable

                copy_permissions=form_result['group_copy_permissions']

            )

            Session().commit()

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

        except formencode.Invalid as errors:

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during creation of repository group %s') \

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

            #TODO: maybe we should get back to the main view, not the admin one

            raise HTTPFound(location=url('repos_groups', parent_group=parent_group_id))

        h.flash(_('Created repository group %s') % gr.group_name,

                category='success')

        raise HTTPFound(location=url('repos_group_home', group_name=gr.group_name))

    __mapper_args__ = {'order_by': 'group_name'} # TODO: Deprecated as of SQLAlchemy 1.1.

    SEP = ' » '

    group_id = Column(Integer(), primary_key=True)

    group_name = Column(Unicode(255), nullable=False, unique=True) # full path

    group_description = Column(Unicode(10000), nullable=False)

    enable_locking = Column(Boolean(), nullable=False, default=False)

    owner_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')

        if edit:

            #FIXME: do a special check that we cannot move a group to one of

            #its children

            pass

                              v.OneOf(repo_group_ids, hideList=False,

                                      testValueList=True,

                                      if_missing=None, not_empty=True),

                              v.Int(min=-1, not_empty=True))

        enable_locking = v.StringBoolean(if_missing=False)

        chained_validators = [v.ValidRepoGroup(edit, old_data)]

        try:

            repo_group = self._get_repo_group(repo_group)

            old_path = repo_group.full_path

            # change properties

            repo_group.group_description = form_data['group_description']

            repo_group.enable_locking = form_data['enable_locking']

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

            new_path = repo_group.full_path

            self.sa.add(repo_group)

            # iterate over all members of this groups and do fixes

            # set locking if given

    def get_repo_groups(self, groups=None):

        """Return the repo groups the user has access to

        If no groups are specified, use top level groups.

        """

        if groups is None:

            groups = RepoGroup.query() \

        return RepoGroupList(groups)

    def mark_for_invalidation(self, repo_name):

        """

        Mark caches of this repo invalid in the database.

def ValidRepoGroup(edit=False, old_data=None):

    old_data = old_data or {}

    class _validator(formencode.validators.FancyValidator):

        messages = {

            'group_exists': _('Group "%(group_name)s" already exists'),

            'repo_exists':

                _('Repository with name "%(group_name)s" already exists')

        }

        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)

            # check for parent of self

            parent_of_self = lambda: (

            )

            if edit and parent_of_self():

                raise formencode.Invalid(msg, value, state,

                )

            old_gname = None

            if edit:

                old_gname = RepoGroup.get(old_data.get('group_id')).group_name

            if old_gname != group_name or not edit:

                # check group

                gr = RepoGroup.query() \

                      .filter(RepoGroup.group_name == slug) \

                      .scalar()

                if gr is not None:

                    msg = M(self, 'group_exists', state, group_name=slug)

                    raise formencode.Invalid(msg, value, state,

                            error_dict=dict(group_name=msg)

            forbidden_in_root = gr is None and not can_create_in_root

            val = HasRepoGroupPermissionAny('group.admin')

            forbidden = not val(gr_name, 'can create group validator')

            if forbidden_in_root or forbidden:

                msg = M(self, 'permission_denied', state)

                raise formencode.Invalid(msg, value, state,

                )

    return _validator

def ValidPerms(type_='repo'):

                <div class="textarea-repo editor">

                    ${h.textarea('group_description',cols=23,rows=5,class_="medium")}

                </div>

            </div>

            <div class="form-group">

                <div class="input">

                </div>

            </div>

            <div id="copy_perms" class="field">

                <label class="control-label" for="group_copy_permissions">${_('Copy parent group permissions')}:</label>

                <div class="checkboxes">

                $('#copy_perms').show();

            }

            else{

                $('#copy_perms').hide();

            }

        }

            'dropdownAutoWidth': true

        });

            setCopyPermsOption(e.val);

        });

        $('#group_name').focus();

    });

</script>

</%def>

            <div class="textarea text-area editor">

                ${h.textarea('group_description',cols=23,rows=5,class_="medium")}

            </div>

        </div>

        <div class="form-group">

            <div class="input">

            </div>

        </div>

        <div class="form-group">

            <label class="control-label" for="enable_locking">${_('Enable locking')}:</label>

            <div class="checkboxes">

    </div>

</div>

${h.end_form()}

<script>

    $(document).ready(function(){

            'dropdownAutoWidth': true

        });

    });

</script>

        return defs

    def _get_group_create_params(self, **custom):

        defs = dict(

            group_name=None,

            group_description=u'DESC',

            perms_updates=[],

            perms_new=[],

            enable_locking=False,

            recursive=False

        )

        defs.update(custom)

                return gr

        form_data = self._get_group_create_params(group_name=name, **kwargs)

        owner = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)

        gr = RepoGroupModel().create(

            group_name=form_data['group_name'],

            group_description=form_data['group_name'],

        Session().commit()

        gr = RepoGroup.get_by_group_name(gr.group_name)

        return gr

    def destroy_repo_group(self, repogroupid):

        RepoGroupModel().delete(repogroupid)

    """

    test_u1 = UserModel().create_or_update(

        username=u'test_u1', password=u'qweqwe',

        email=u'test_u1@example.com', firstname=u'test_u1', lastname=u'test_u1'

    )

    g0 = fixture.create_repo_group(u'g0')

    g0_1_1_r1 = fixture.create_repo(u'g0/g0_1/g0_1_1/g0_1_1_r1', repo_group=g0_1_1)

    g0_1_1_r2 = fixture.create_repo(u'g0/g0_1/g0_1_1/g0_1_1_r2', repo_group=g0_1_1)

    g0_1_r1 = fixture.create_repo(u'g0/g0_1/g0_1_r1', repo_group=g0_1)

    g0_2_r1 = fixture.create_repo(u'g0/g0_2/g0_2_r1', repo_group=g0_2)

    g0_2_r2 = fixture.create_repo(u'g0/g0_2/g0_2_r2', repo_group=g0_2)

    g0_3_r1 = fixture.create_repo(u'g0/g0_3/g0_3_r1', repo_group=g0_3)

    g0_3_r2_private = fixture.create_repo(u'g0/g0_3/g0_3_r1_private',

                                          repo_group=g0_3, repo_private=True)

    return test_u1

fixture = Fixture()

def _update_group(id_, group_name, desc=u'desc', parent_id=None):

    form_data = fixture._get_group_create_params(group_name=group_name,

                                                 group_desc=desc,

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

    return gr

def _update_repo(name, **kwargs):

    form_data = fixture._get_repo_create_params(**kwargs)

    def test_create_same_name_group(self):

        with pytest.raises(IntegrityError):

            fixture.create_repo_group(u'newGroup')

        Session().rollback()

    def test_same_subgroup(self):

        assert sg1.parent_group == self.g1

        assert sg1.full_path == 'test1/sub1'

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

        assert ssg1.parent_group == sg1

        assert ssg1.full_path == 'test1/sub1/subsub1'

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

    def test_remove_group(self):

        sg1 = fixture.create_repo_group(u'deleteme')

        self.__delete_group(sg1.group_id)

        assert RepoGroup.get(sg1.group_id) == None

        assert not self.__check_path('deteteme')

        self.__delete_group(sg1.group_id)

        assert RepoGroup.get(sg1.group_id) == None

        assert not self.__check_path('test1', 'deteteme')

    def test_rename_single_group(self):

        new_sg1 = _update_group(sg1.group_id, u'after')

        assert self.__check_path('after')

        assert RepoGroup.get_by_group_name(u'initial') == None

    def test_update_group_parent(self):

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

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

        assert RepoGroup.get_by_group_name(u'test1/initial') == None

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

        # test repo

        assert r.repo_name == RepoGroup.url_sep().join(['g2', 'g1',

                                                                r.just_name])

    def test_move_to_root(self):

        g1 = fixture.create_repo_group(u't11')

        assert g2.full_path == 't11/t22'

        assert self.__check_path('t11', 't22')

        g2 = _update_group(g2.group_id, u'g22', parent_id=None)

        Session().commit()

        assert g2.full_path == 'g22'

        assert not self.__check_path('t11', 't22')

        assert self.__check_path('g22')

    def test_rename_top_level_group_in_nested_setup(self):

        g1 = fixture.create_repo_group(u'L1')

        r = fixture.create_repo(u'L1/L2/L3/L3_REPO', repo_group=g3.group_id)

        ##rename L1 all groups should be now changed

        _update_group(g1.group_id, u'L1_NEW')

        Session().commit()

        assert g2.full_path == 'L1_NEW/L2'

        assert g3.full_path == 'L1_NEW/L2/L3'

        assert r.repo_name == 'L1_NEW/L2/L3/L3_REPO'

    def test_change_parent_of_top_level_group_in_nested_setup(self):

        g1 = fixture.create_repo_group(u'R1')

        g4 = fixture.create_repo_group(u'R1_NEW')

        r = fixture.create_repo(u'R1/R2/R3/R3_REPO', repo_group=g3.group_id)

        ##rename L1 all groups should be now changed

        _update_group(g1.group_id, u'R1', parent_id=g4.group_id)

        Session().commit()

        assert g2.full_path == 'R1_NEW/R1/R2'

        assert g3.full_path == 'R1_NEW/R1/R2/R3'

        assert r.repo_name == 'R1_NEW/R1/R2/R3/R3_REPO'

    def test_change_parent_of_top_level_group_in_nested_setup_with_rename(self):

        g1 = fixture.create_repo_group(u'X1')

        g4 = fixture.create_repo_group(u'X1_NEW')

        r = fixture.create_repo(u'X1/X2/X3/X3_REPO', repo_group=g3.group_id)

        ##rename L1 all groups should be now changed

        _update_group(g1.group_id, u'X1_PRIM', parent_id=g4.group_id)

        validator = v.ValidRepoGroup(edit=True,

                                      old_data={'group_id':  gr.group_id})

        with pytest.raises(formencode.Invalid):

            validator.to_python({

                                        'group_name': gr.group_name + 'n',

                                        })

        model.delete(gr)

    def test_ValidPassword(self):

        validator = v.ValidPassword()

        assert 'lol' == validator.to_python('lol')