def create(self):

        self.__load_defaults()

        # permissions for can create group based on parent_id are checked

        # here in the Form

        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:

            return htmlfill.render(

                render('admin/repo_groups/repo_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

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

    def new(self):

        if HasPermissionAny('hg.admin')('group create'):

            #we're global admin, we're ok and we can create TOP level groups

            pass

        else:

            # we pass in parent group into creation form, thus we know

class RepoGroup(Base, BaseDbModel):

    __tablename__ = 'groups'

    __table_args__ = (

        CheckConstraint('group_id != group_parent_id', name='ck_groups_no_self_parent'),

        _table_args_default_dict,

    )

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

    users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')

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

    owner = relationship('User')

    @classmethod

    def query(cls, sorted=False):

        group_name = All(v.UnicodeString(strip=True, min=1, not_empty=True),

                         v.SlugifyName(),

                         v.ValidRegex(msg=_('Name must not contain only digits'))(r'(?!^\d+$)^.+$'))

        group_description = v.UnicodeString(strip=True, min=1,

                                            not_empty=False)

        group_copy_permissions = v.StringBoolean(if_missing=False)

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

    return _RepoGroupForm

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

    class _RegisterForm(formencode.Schema):

                break

        return updates

    def update(self, repo_group, form_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

            # if obj is a repoGroup also fix the name of the group according

            # to the parent

            # if obj is a Repo fix it's name

            # this can be potentially heavy operation

            for obj in repo_group.recursive_groups_and_repos():

                #set the value from it's parent

        return repos

    def get_repos(self, repos):

        """Return the repos the user has access to"""

        return RepoList(repos)

    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.

        :param repo_name: the repo for which caches should be marked invalid

        """

        CacheInvalidation.set_invalidate(repo_name)

        repo = Repository.get_by_repo_name(repo_name)

        if repo is not None:

            repo.update_changeset_cache()

                raise formencode.Invalid(msg, value, state,

                    error_dict=dict(users_group_name=msg)

                )

    return _validator

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)

                    )

                # check for same repo

                repo = Repository.query() \

                      .filter(Repository.repo_name == slug) \

                      .scalar()

            gr_name = gr.group_name if gr is not None else None # None means ROOT location

            if can_create_in_root and gr is None:

                #we can create in root, we're fine no validations required

                return

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

    if type_ == 'repo_group':

        EMPTY_PERM = 'group.none'

    elif type_ == 'repo':

        EMPTY_PERM = 'repository.none'

    elif type_ == 'user_group':

        EMPTY_PERM = 'usergroup.none'

                    ${h.text('group_name',class_='small')}

                </div>

            </div>

            <div class="form-group">

                <label class="control-label" for="group_description">${_('Description')}:</label>

                <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">

                    ${h.checkbox('group_copy_permissions',value="True")}

                    <span class="help-block">${_('Copy permission set from parent repository group.')}</span>

                </div>

            </div>

            <div class="form-group">

    ${h.end_form()}

</div>

<script>

    $(document).ready(function(){

        var setCopyPermsOption = function(group_val){

            if(group_val != "-1"){

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

            }

            else{

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

            }

        }

            'dropdownAutoWidth': true

        });

            setCopyPermsOption(e.val);

        });

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

    });

</script>

</%def>

                ${h.text('group_name',class_='medium')}

            </div>

        </div>

        <div class="form-group">

            <label class="control-label" for="group_description">${_('Description')}:</label>

            <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">

                ${h.checkbox('enable_locking',value="True")}

                <span class="help-block">${_('Enable lock-by-pulling on group. This option will be applied to all other groups and repositories inside')}</span>

            </div>

        </div>

        <div class="form-group">

    <div class="form-horizontal">

        <div class="form-group">

            <div class="buttons">

                ${h.submit('remove_%s' % c.repo_group.group_name,_('Remove this group'),class_="btn btn-danger",onclick="return confirm('"+_('Confirm to delete this group')+"');")}

            </div>

        </div>

    </div>

</div>

${h.end_form()}

<script>

    $(document).ready(function(){

            'dropdownAutoWidth': true

        });

    });

</script>

            defs.update({'repo_name_full': defs['repo_name']})

        # fix the repo name if passed as repo_name_full

        if defs['repo_name']:

            defs['repo_name'] = defs['repo_name'].split('/')[-1]

        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 defs

    def _get_user_create_params(self, name, **custom):

        defs = dict(

            username=name,

    def create_repo_group(self, name, **kwargs):

        if 'skip_if_exists' in kwargs:

            del kwargs['skip_if_exists']

            gr = RepoGroup.get_by_group_name(group_name=name)

            if gr:

                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)

        Session().commit()

    def create_user(self, name, **kwargs):

        if 'skip_if_exists' in kwargs:

            del kwargs['skip_if_exists']

            user = User.get_by_username(name)

     |

     |__[g0_3] 1 repo

        |

        |_<g0/g0_3/g0_3_r1>

        |_<g0/g0_3/g0_3_r2_private>

    """

    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

def expected_count(group_name, objects=False):

    repo_group = RepoGroup.get_by_group_name(group_name=group_name)

    objs = repo_group.recursive_groups_and_repos()

    if objects:

        return objs

    return len(objs)

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.repo import RepoModel

from kallithea.model.db import RepoGroup

from kallithea.model.meta import Session

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)

    if not 'repo_name' in kwargs:

        form_data['repo_name'] = name

    if not 'perms_new' in kwargs:

        form_data['perms_new'] = []

    if not 'perms_updates' in kwargs:

        form_data['perms_updates'] = []

        g = fixture.create_repo_group(u'newGroup')

        Session().commit()

        assert g.full_path == 'newGroup'

        assert self.__check_path('newGroup')

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

        sg1 = fixture.create_repo_group(u'initial')

        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)

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

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

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

        assert self.__check_path('hello')

        Session().commit()

        assert r.repo_name == 'g1/john'

        _update_group(g1.group_id, u'g1', parent_id=g2.group_id)

        assert self.__check_path('g2', 'g1')

        # 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.group_name == 'g22'

        # we moved out group from t1 to '' so it's full path should be 'g2'

        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 g1.full_path == 'L1_NEW'

        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 g1.full_path == 'R1_NEW/R1'

        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)

        Session().commit()

        assert g1.full_path == 'X1_NEW/X1_PRIM'

        assert g2.full_path == 'X1_NEW/X1_PRIM/X2'

        assert g3.full_path == 'X1_NEW/X1_PRIM/X2/X3'

        assert r.repo_name == 'X1_NEW/X1_PRIM/X2/X3/X3_REPO'

        gr = model.create(group_name=u'test_gr', group_description=u'desc',

                          parent=None,

                          just_db=True,

                          owner=TEST_USER_ADMIN_LOGIN)

        with pytest.raises(formencode.Invalid):

            validator.to_python({'group_name': gr.group_name, })

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

        assert None == validator.to_python(None)

        with pytest.raises(formencode.Invalid):

            validator.to_python('ąćżź')

    def test_ValidPasswordsMatch(self):

        validator = v.ValidPasswordsMatch('new_password', 'password_confirmation')