Python db.UserGroup类代码示例

    def grant_user_group_permission(self, target_user_group, user_group, perm):
        """
        Grant user group permission for given target_user_group

        :param target_user_group:
        :param user_group:
        :param perm:
        """
        target_user_group = UserGroup.guess_instance(target_user_group)
        user_group = UserGroup.guess_instance(user_group)
        permission = Permission.guess_instance(perm)
        # forbid assigning same user group to itself
        if target_user_group == user_group:
            raise RepoGroupAssignmentError('target repo:%s cannot be '
                                           'assigned to itself' % target_user_group)

        # check if we have that permission already
        obj = UserGroupUserGroupToPerm.query() \
            .filter(UserGroupUserGroupToPerm.target_user_group == target_user_group) \
            .filter(UserGroupUserGroupToPerm.user_group == user_group) \
            .scalar()
        if obj is None:
            # create new !
            obj = UserGroupUserGroupToPerm()
            Session().add(obj)
        obj.user_group = user_group
        obj.target_user_group = target_user_group
        obj.permission = permission
        log.debug('Granted perm %s to %s on %s', perm, target_user_group, user_group)
        return obj

        def validate_python(self, value, state):
            if value in ['default']:
                msg = M(self, 'invalid_group', state)
                raise formencode.Invalid(msg, value, state,
                    error_dict=dict(users_group_name=msg)
                )
            #check if group is unique
            old_ugname = None
            if edit:
                old_id = old_data.get('users_group_id')
                old_ugname = UserGroup.get(old_id).users_group_name

            if old_ugname != value or not edit:
                is_existing_group = UserGroup.get_by_group_name(value,
                                                        case_insensitive=True)
                if is_existing_group:
                    msg = M(self, 'group_exist', state, usergroup=value)
                    raise formencode.Invalid(msg, value, state,
                        error_dict=dict(users_group_name=msg)
                    )

            if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:
                msg = M(self, 'invalid_usergroup_name', state)
                raise formencode.Invalid(msg, value, state,
                    error_dict=dict(users_group_name=msg)
                )

 def create_user_group(self, name, **kwargs):
     if 'skip_if_exists' in kwargs:
         del kwargs['skip_if_exists']
         gr = UserGroup.get_by_group_name(group_name=name)
         if gr:
             return gr
     form_data = self._get_user_group_create_params(name, **kwargs)
     owner = kwargs.get('cur_user', TEST_USER_ADMIN_LOGIN)
     user_group = UserGroupModel().create(
         name=form_data['users_group_name'],
         description=form_data['user_group_description'],
         owner=owner, active=form_data['users_group_active'],
         group_data=form_data['user_group_data'])
     Session().commit()
     user_group = UserGroup.get_by_group_name(user_group.users_group_name)
     return user_group

    def grant_user_permission(self, user_group, user, perm):
        """
        Grant permission for user on given user group, or update
        existing one if found

        :param user_group: Instance of UserGroup, users_group_id,
            or users_group_name
        :param user: Instance of User, user_id or username
        :param perm: Instance of Permission, or permission_name
        """

        user_group = UserGroup.guess_instance(user_group)
        user = User.guess_instance(user)
        permission = Permission.guess_instance(perm)

        # check if we have that permission already
        obj = UserUserGroupToPerm.query() \
            .filter(UserUserGroupToPerm.user == user) \
            .filter(UserUserGroupToPerm.user_group == user_group) \
            .scalar()
        if obj is None:
            # create new !
            obj = UserUserGroupToPerm()
            Session().add(obj)
        obj.user_group = user_group
        obj.user = user
        obj.permission = permission
        log.debug('Granted perm %s to %s on %s', perm, user, user_group)
        return obj

    def grant_user_group_permission(self, repo, group_name, perm):
        """
        Grant permission for user group on given repository, or update
        existing one if found

        :param repo: Instance of Repository, repository_id, or repository name
        :param group_name: Instance of UserGroup, users_group_id,
            or user group name
        :param perm: Instance of Permission, or permission_name
        """
        repo = Repository.guess_instance(repo)
        group_name = UserGroup.guess_instance(group_name)
        permission = Permission.guess_instance(perm)

        # check if we have that permission already
        obj = UserGroupRepoToPerm.query() \
            .filter(UserGroupRepoToPerm.users_group == group_name) \
            .filter(UserGroupRepoToPerm.repository == repo) \
            .scalar()

        if obj is None:
            # create new
            obj = UserGroupRepoToPerm()
            Session().add(obj)

        obj.repository = repo
        obj.users_group = group_name
        obj.permission = permission
        log.debug('Granted perm %s to %s on %s', perm, group_name, repo)
        return obj

    def has_perm(self, user_group, perm):
        user_group = UserGroup.guess_instance(user_group)
        perm = Permission.guess_instance(perm)

        return UserGroupToPerm.query() \
            .filter(UserGroupToPerm.users_group == user_group) \
            .filter(UserGroupToPerm.permission == perm).scalar() is not None

    def test_create_and_remove(self):
        usr = UserModel().create_or_update(username=u'test_user',
                                           password=u'qweqwe',
                                           email=u'[email protected]',
                                           firstname=u'u1', lastname=u'u1')
        Session().commit()
        assert User.get_by_username(u'test_user') == usr
        assert User.get_by_username(u'test_USER', case_insensitive=True) == usr
        # User.get_by_username without explicit request for case insensitivty
        # will use database case sensitivity. The following will thus return
        # None on for example PostgreSQL but find test_user on MySQL - we are
        # fine with leaving that as undefined as long as it doesn't crash.
        User.get_by_username(u'test_USER', case_insensitive=False)

        # make user group
        user_group = fixture.create_user_group(u'some_example_group')
        Session().commit()

        UserGroupModel().add_user_to_group(user_group, usr)
        Session().commit()

        assert UserGroup.get(user_group.users_group_id) == user_group
        assert UserGroupMember.query().count() == 1
        UserModel().delete(usr.user_id)
        Session().commit()

        assert UserGroupMember.query().all() == []

    def test_enforce_groups(self, pre_existing, regular_should_be,
                            external_should_be, groups, expected):
        # delete all groups
        for gr in UserGroup.query():
            fixture.destroy_user_group(gr)
        Session().commit()

        user = User.get_by_username(TEST_USER_REGULAR_LOGIN)
        for gr in pre_existing:
            gr = fixture.create_user_group(gr)
        Session().commit()

        # make sure use is just in those groups
        for gr in regular_should_be:
            gr = fixture.create_user_group(gr)
            Session().commit()
            UserGroupModel().add_user_to_group(gr, user)
            Session().commit()

        # now special external groups created by auth plugins
        for gr in external_should_be:
            gr = fixture.create_user_group(gr, user_group_data={'extern_type': 'container'})
            Session().commit()
            UserGroupModel().add_user_to_group(gr, user)
            Session().commit()

        UserGroupModel().enforce_groups(user, groups, 'container')
        Session().commit()

        user = User.get_by_username(TEST_USER_REGULAR_LOGIN)
        in_groups = user.group_member
        assert expected == [x.users_group.users_group_name for x in in_groups]

    def enforce_groups(self, user, groups, extern_type=None):
        user = User.guess_instance(user)
        log.debug('Enforcing groups %s on user %s', user, groups)
        current_groups = user.group_member
        # find the external created groups
        externals = [x.users_group for x in current_groups
                     if 'extern_type' in x.users_group.group_data]

        # calculate from what groups user should be removed
        # externals that are not in groups
        for gr in externals:
            if gr.users_group_name not in groups:
                log.debug('Removing user %s from user group %s', user, gr)
                self.remove_user_from_group(gr, user)

        # now we calculate in which groups user should be == groups params
        owner = User.get_first_admin().username
        for gr in set(groups):
            existing_group = UserGroup.get_by_group_name(gr)
            if not existing_group:
                desc = u'Automatically created from plugin:%s' % extern_type
                # we use first admin account to set the owner of the group
                existing_group = UserGroupModel().create(gr, desc, owner,
                                        group_data={'extern_type': extern_type})

            # we can only add users to special groups created via plugins
            managed = 'extern_type' in existing_group.group_data
            if managed:
                log.debug('Adding user %s to user group %s', user, gr)
                UserGroupModel().add_user_to_group(existing_group, user)
            else:
                log.debug('Skipping addition to group %s since it is '
                          'not managed by auth plugins' % gr)

    def revoke_user_group_permission(self, target_user_group, user_group):
        """
        Revoke user group permission for given target_user_group

        :param target_user_group:
        :param user_group:
        """
        target_user_group = UserGroup.guess_instance(target_user_group)
        user_group = UserGroup.guess_instance(user_group)

        obj = UserGroupUserGroupToPerm.query() \
            .filter(UserGroupUserGroupToPerm.target_user_group == target_user_group) \
            .filter(UserGroupUserGroupToPerm.user_group == user_group) \
            .scalar()
        if obj is not None:
            Session().delete(obj)
            log.debug('Revoked perm on %s on %s', target_user_group, user_group)

    def edit_members(self, id):
        c.user_group = UserGroup.get_or_404(id)
        c.active = 'members'
        c.group_members_obj = sorted((x.user for x in c.user_group.members),
                                     key=lambda u: u.username.lower())

        c.group_members = [(x.user_id, x.username) for x in c.group_members_obj]
        return render('admin/user_groups/user_group_edit.html')

    def revoke_perm(self, user_group, perm):
        user_group = UserGroup.guess_instance(user_group)
        perm = Permission.guess_instance(perm)

        obj = UserGroupToPerm.query() \
            .filter(UserGroupToPerm.users_group == user_group) \
            .filter(UserGroupToPerm.permission == perm).scalar()
        if obj is not None:
            Session().delete(obj)

    def __load_defaults(self, user_group_id):
        """
        Load defaults settings for edit, and update

        :param user_group_id:
        """
        user_group = UserGroup.get_or_404(user_group_id)
        data = user_group.get_dict()
        return data

 def get_user_groups_js(self):
     user_groups = UserGroup.query() \
         .filter(UserGroup.users_group_active == True) \
         .order_by(UserGroup.users_group_name) \
         .options(subqueryload(UserGroup.members)) \
         .all()
     user_groups = UserGroupList(user_groups, perm_level='read')
     return [
         {
             'id': gr.users_group_id,
             'grname': gr.users_group_name,
             'grmembers': len(gr.members),
         } for gr in user_groups]

    def edit(self, id, format='html'):
        c.user_group = UserGroup.get_or_404(id)
        c.active = 'settings'
        self.__load_data(id)

        defaults = self.__load_defaults(id)

        return htmlfill.render(
            render('admin/user_groups/user_group_edit.html'),
            defaults=defaults,
            encoding="UTF-8",
            force_defaults=False
        )