feat(group): manage users in user groups (#10940)

# Which Problems Are Solved

1. Adding users to user groups and removing users from user groups.
2. Searching for users in user groups by group IDs or user IDs

# How the Problems Are Solved

By adding:
1. The API definitions to manage users in users groups
3. The command-layer implementation of adding users/removing users
to/from user groups.
4. The projection table group_users1
5. Query-side implementation to search for users in user groups

# Additional Changes

1. Remove debug statements from unit tests.
2. Fix removal of groups when orgs are removed
3. Add unit tests for groups projection

# Additional Context

* Related to #9702 
* Follow-up for PRs 
  * https://github.com/zitadel/zitadel/pull/10455
  * https://github.com/zitadel/zitadel/pull/10758
  * https://github.com/zitadel/zitadel/pull/10853
This commit is contained in:
Gayathri Vijayan
2025-10-28 13:23:54 +00:00
committed by GitHub
parent c2a0b9d187
commit ad8e8bf61f
34 changed files with 3825 additions and 88 deletions
+16 -5
View File
@@ -56,7 +56,7 @@ func (c *Commands) CreateGroup(ctx context.Context, group *CreateGroup) (details
}
// check if a group with the same ID already exists
groupWriteModel, err := c.getGroupWriteModelByID(ctx, group.AggregateID, group.ResourceOwner)
groupWriteModel, err := c.getGroupWriteModelByID(ctx, group.AggregateID, group.ResourceOwner, nil)
if err != nil {
return nil, err
}
@@ -100,7 +100,7 @@ func (c *Commands) UpdateGroup(ctx context.Context, groupUpdate *UpdateGroup) (d
return nil, err
}
existingGroup, err := c.getGroupWriteModelByID(ctx, groupUpdate.AggregateID, groupUpdate.ResourceOwner)
existingGroup, err := c.getGroupWriteModelByID(ctx, groupUpdate.AggregateID, groupUpdate.ResourceOwner, nil)
if err != nil {
return nil, err
}
@@ -136,7 +136,7 @@ func (c *Commands) DeleteGroup(ctx context.Context, groupID string) (details *do
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
existingGroup, err := c.getGroupWriteModelByID(ctx, groupID, "")
existingGroup, err := c.getGroupWriteModelByID(ctx, groupID, "", nil)
if err != nil {
return nil, err
}
@@ -160,11 +160,22 @@ func (c *Commands) DeleteGroup(ctx context.Context, groupID string) (details *do
return writeModelToObjectDetails(&existingGroup.WriteModel), nil
}
func (c *Commands) getGroupWriteModelByID(ctx context.Context, id, orgID string) (*GroupWriteModel, error) {
groupWriteModel := NewGroupWriteModel(id, orgID)
func (c *Commands) getGroupWriteModelByID(ctx context.Context, groupID, orgID string, userIDs []string) (*GroupWriteModel, error) {
groupWriteModel := NewGroupWriteModel(groupID, orgID, userIDs)
err := c.eventstore.FilterToQueryReducer(ctx, groupWriteModel)
if err != nil {
return nil, err
}
return groupWriteModel, nil
}
func (c *Commands) checkGroupExists(ctx context.Context, groupID string, userIDs []string) (*GroupWriteModel, error) {
group, err := c.getGroupWriteModelByID(ctx, groupID, "", userIDs)
if err != nil {
return nil, err
}
if !group.State.Exists() {
return nil, zerrors.ThrowPreconditionFailed(nil, "CMDGRP-eQfeur", "Errors.Group.NotFound")
}
return group, nil
}
+28 -6
View File
@@ -16,29 +16,43 @@ type GroupWriteModel struct {
Description string
State domain.GroupState
UserIDs []string
existingUserIDs map[string]struct{}
}
// NewGroupWriteModel initializes a new instance of GroupWriteModel from the given Group.
func NewGroupWriteModel(id, orgID string) *GroupWriteModel {
func NewGroupWriteModel(groupID, orgID string, userIDs []string) *GroupWriteModel {
return &GroupWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: id,
AggregateID: groupID,
ResourceOwner: orgID,
},
UserIDs: userIDs,
existingUserIDs: make(map[string]struct{}),
}
}
func (g *GroupWriteModel) GetWriteModel() *eventstore.WriteModel {
return &g.WriteModel
}
// Query constructs a search query for retrieving group-related events based on the GroupWriteModel attributes.
func (g *GroupWriteModel) Query() *eventstore.SearchQueryBuilder {
eventTypes := []eventstore.EventType{
group.GroupAddedEventType,
group.GroupChangedEventType,
group.GroupRemovedEventType,
}
if g.UserIDs != nil {
eventTypes = append(eventTypes, group.GroupUsersAddedEventType, group.GroupUsersRemovedEventType)
}
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(g.ResourceOwner).
AddQuery().
AggregateTypes(group.AggregateType).
AggregateIDs(g.AggregateID).
EventTypes(
group.GroupAddedEventType,
group.GroupChangedEventType,
group.GroupRemovedEventType).Builder()
EventTypes(eventTypes...).Builder()
}
func (g *GroupWriteModel) Reduce() error {
@@ -58,6 +72,14 @@ func (g *GroupWriteModel) Reduce() error {
}
case *group.GroupRemovedEvent:
g.State = domain.GroupStateRemoved
case *group.GroupUsersAddedEvent:
for _, userID := range e.UserIDs {
g.existingUserIDs[userID] = struct{}{}
}
case *group.GroupUsersRemovedEvent:
for _, userID := range e.UserIDs {
delete(g.existingUserIDs, userID)
}
}
}
return g.WriteModel.Reduce()
+131
View File
@@ -0,0 +1,131 @@
package command
import (
"context"
"slices"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/eventstore"
repo "github.com/zitadel/zitadel/internal/repository/group"
"github.com/zitadel/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddUsersToGroup(ctx context.Context, groupID string, userIDs []string) (_ *domain.ObjectDetails, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
// precondition: check whether the group exists
group, err := c.checkGroupExists(ctx, groupID, userIDs)
if err != nil {
return nil, err
}
// check whether the requester has permissions to add users to the group
err = c.checkPermissionAddUserToGroup(ctx, group.ResourceOwner, group.AggregateID)
if err != nil {
return nil, err
}
// add the users to the group
return c.addUsersToGroup(ctx, group)
}
func (c *Commands) RemoveUsersFromGroup(ctx context.Context, groupID string, userIDs []string) (_ *domain.ObjectDetails, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
// precondition: check whether the group exists
group, err := c.checkGroupExists(ctx, groupID, userIDs)
if err != nil {
return nil, err
}
// check whether the requester has permissions to remove users from the group
err = c.checkPermissionRemoveUserFromGroup(ctx, group.ResourceOwner, group.AggregateID)
if err != nil {
return nil, err
}
userIDsToRemove := group.getUserIDsToRemove()
if len(userIDsToRemove) == 0 {
// the userIDs are not present in the group; desired state achieved
return writeModelToObjectDetails(&group.WriteModel), nil
}
// remove users from the group
return c.pushAppendAndReduceDetails(ctx,
group,
repo.NewGroupUsersRemovedEvent(
ctx,
GroupAggregateFromWriteModel(ctx, &group.WriteModel),
userIDsToRemove,
))
}
func (c *Commands) addUsersToGroup(ctx context.Context, group *GroupWriteModel) (*domain.ObjectDetails, error) {
userIDsToAdd := group.getUserIDsToAdd()
if len(userIDsToAdd) == 0 {
// no new users to add
return writeModelToObjectDetails(&group.WriteModel), nil
}
// precondition: check whether the users exist
for _, userID := range userIDsToAdd {
// check whether the user exists in the same organization as the group
_, err := c.checkUserExists(ctx, userID, group.ResourceOwner)
if err != nil {
return nil, err
}
}
// add users to the group
return c.pushAppendAndReduceDetails(ctx,
group,
repo.NewGroupUsersAddedEvent(
ctx,
GroupAggregateFromWriteModel(ctx, &group.WriteModel),
userIDsToAdd,
),
)
}
// getUserIDsToAdd returns the userIDs that are not already in the group
func (g *GroupWriteModel) getUserIDsToAdd() []string {
userIDsToAdd := make([]string, 0)
for _, userID := range g.UserIDs {
if _, ok := g.existingUserIDs[userID]; !ok && !slices.Contains(userIDsToAdd, userID) {
userIDsToAdd = append(userIDsToAdd, userID)
}
}
return userIDsToAdd
}
// getUserIDsToRemove returns the userIDs that are in the group and should be removed
// if a userID is not in the group, the desired state has already been achieved
func (g *GroupWriteModel) getUserIDsToRemove() []string {
userIDsToRemove := make([]string, 0)
for _, userID := range g.UserIDs {
if _, ok := g.existingUserIDs[userID]; ok && !slices.Contains(userIDsToRemove, userID) {
userIDsToRemove = append(userIDsToRemove, userID)
}
}
return userIDsToRemove
}
// removeUserFromGroups returns the events to remove a user from multiple groups.
// This is needed when a user is deleted and subsequently needs to be removed from all groups.
// Note: Ensure that the groupIDs are retrieved via SearchGroupUsers before calling this method
func (c *Commands) removeUserFromGroups(ctx context.Context, userID string, groupIDs []string, resourceOwner string) ([]eventstore.Command, error) {
events := make([]eventstore.Command, 0, len(groupIDs))
for _, groupID := range groupIDs {
events = append(
events,
repo.NewGroupUsersRemovedEvent(
ctx,
&repo.NewAggregate(groupID, resourceOwner).Aggregate,
[]string{userID},
),
)
}
return events, nil
}
+541
View File
@@ -0,0 +1,541 @@
package command
import (
"context"
"errors"
"testing"
"github.com/stretchr/testify/require"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/repository/group"
"github.com/zitadel/zitadel/internal/repository/user"
"github.com/zitadel/zitadel/internal/zerrors"
)
func TestCommands_AddUsersToGroup(t *testing.T) {
t.Parallel()
filterErr := errors.New("filter error")
pushErr := errors.New("push error")
type fields struct {
eventstore func(t *testing.T) *eventstore.Eventstore
checkPermission domain.PermissionCheck
}
type args struct {
groupID string
userIDs []string
}
tests := []struct {
name string
fields fields
args args
want *domain.ObjectDetails
wantErr func(error) bool
}{
{
name: "failed to get group write model, error",
fields: fields{
eventstore: expectEventstore(
expectFilterError(filterErr),
),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
wantErr: func(err error) bool {
return errors.Is(err, filterErr)
},
},
{
name: "group not found, error",
fields: fields{
eventstore: expectEventstore(
expectFilter(),
),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
wantErr: zerrors.IsPreconditionFailed,
},
{
name: "missing permission, error",
fields: fields{
eventstore: expectEventstore(
expectFilter(
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
)),
checkPermission: newMockPermissionCheckNotAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
wantErr: zerrors.IsPermissionDenied,
},
{
name: "user not found, error",
fields: fields{
eventstore: expectEventstore(
expectFilter(
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
),
expectFilter(), // to get the user write model for user1
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
wantErr: zerrors.IsPreconditionFailed,
},
{
name: "some users already exist in the group, ok",
fields: fields{
eventstore: expectEventstore(
expectFilter( // to get the group write model
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
eventFromEventPusher(
addNewGroupUsersAddedEvent("group1", "org1", []string{"user1"}),
),
),
expectFilter( // to get the user write model to check if user1 exists
eventFromEventPusher(
addNewUserEvent("user2", "org1"),
),
),
expectPush(
group.NewGroupUsersAddedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user2"},
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
want: &domain.ObjectDetails{
ID: "group1",
ResourceOwner: "org1",
},
},
{
name: "all users already exist in the group, no events pushed, ok",
fields: fields{
eventstore: expectEventstore(
expectFilter( // to get the group write model
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
eventFromEventPusher(
addNewGroupUsersAddedEvent("group1", "org1", []string{"user1", "user2"}),
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
want: &domain.ObjectDetails{
ID: "group1",
ResourceOwner: "org1",
},
},
{
name: "failed to push events, error",
fields: fields{
eventstore: expectEventstore(
expectFilter( // to get the group write model
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
),
expectFilter( // to get the user write model for user1
eventFromEventPusher(
addNewUserEvent("user1", "org1"),
),
),
expectPushFailed(
pushErr,
group.NewGroupUsersAddedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user1"},
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1"},
},
wantErr: func(err error) bool {
return errors.Is(err, pushErr)
},
},
{
name: "all users added, ok",
fields: fields{
eventstore: expectEventstore(
expectFilter( // to get the group write model
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
),
expectFilter( // to get the user write model for user1
eventFromEventPusher(
addNewUserEvent("user1", "org1"),
),
),
expectFilter( // to get the user write model for user2
eventFromEventPusher(
addNewUserEvent("user2", "org1"),
),
),
expectPush(
group.NewGroupUsersAddedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user1", "user2"},
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
want: &domain.ObjectDetails{
ID: "group1",
ResourceOwner: "org1",
},
},
{
name: "all users added (with duplicate users), ok",
fields: fields{
eventstore: expectEventstore(
expectFilter( // to get the group write model
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
),
expectFilter( // to get the user write model for user1
eventFromEventPusher(
addNewUserEvent("user1", "org1"),
),
),
expectFilter( // to get the user write model for user2
eventFromEventPusher(
addNewUserEvent("user2", "org1"),
),
),
expectPush(
group.NewGroupUsersAddedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user1", "user2"},
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2", "user2", "user1"},
},
want: &domain.ObjectDetails{
ID: "group1",
ResourceOwner: "org1",
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
c := &Commands{
eventstore: tt.fields.eventstore(t),
checkPermission: tt.fields.checkPermission,
}
got, err := c.AddUsersToGroup(context.Background(), tt.args.groupID, tt.args.userIDs)
if tt.wantErr != nil {
require.True(t, tt.wantErr(err))
return
}
assertObjectDetails(t, tt.want, got)
})
}
}
func addNewGroupEvent(groupID, orgID string) *group.GroupAddedEvent {
return group.NewGroupAddedEvent(context.Background(),
&group.NewAggregate(groupID, orgID).Aggregate,
groupID,
"group description",
)
}
func TestCommands_RemoveUsersFromGroup(t *testing.T) {
t.Parallel()
filterErr := errors.New("filter error")
pushErr := errors.New("push error")
type fields struct {
eventstore func(t *testing.T) *eventstore.Eventstore
checkPermission domain.PermissionCheck
}
type args struct {
groupID string
userIDs []string
}
tests := []struct {
name string
fields fields
args args
want *domain.ObjectDetails
wantErr func(error) bool
}{
{
name: "failed to get group write model, error",
fields: fields{
eventstore: expectEventstore(
expectFilterError(filterErr),
),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
wantErr: func(err error) bool {
return errors.Is(err, filterErr)
},
},
{
name: "group not found, error",
fields: fields{
eventstore: expectEventstore(
expectFilter(),
),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
wantErr: zerrors.IsPreconditionFailed,
},
{
name: "missing permission, error",
fields: fields{
eventstore: expectEventstore(
expectFilter(
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
)),
checkPermission: newMockPermissionCheckNotAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
wantErr: zerrors.IsPermissionDenied,
},
{
name: "remove users, ok",
fields: fields{
eventstore: expectEventstore(
expectFilter( // to get the group write model
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
eventFromEventPusher(
addNewGroupUsersAddedEvent("group1", "org1", []string{"user1", "user2"}),
),
),
expectPush(
group.NewGroupUsersRemovedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user1", "user2"},
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2"},
},
want: &domain.ObjectDetails{
ResourceOwner: "org1",
ID: "group1",
},
},
{
name: "remove users (with duplicates), ok",
fields: fields{
eventstore: expectEventstore(
expectFilter( // to get the group write model
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
eventFromEventPusher(
addNewGroupUsersAddedEvent("group1", "org1", []string{"user1", "user2"}),
),
),
expectPush(
group.NewGroupUsersRemovedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user1", "user2"},
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1", "user2", "user1", "user2", "user1", "user2"},
},
want: &domain.ObjectDetails{
ResourceOwner: "org1",
ID: "group1",
},
},
{
name: "some users not in group, ok",
fields: fields{
eventstore: expectEventstore(
expectFilter( // to get the group write model
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
eventFromEventPusher(
addNewGroupUsersAddedEvent("group1", "org1", []string{"user1", "user2"}),
),
),
expectPush(
group.NewGroupUsersRemovedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user2"},
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user2", "user3"},
},
want: &domain.ObjectDetails{
ResourceOwner: "org1",
ID: "group1",
},
},
{
name: "all users not in group, ok",
fields: fields{
eventstore: expectEventstore(
expectFilter( // to get the group write model
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
eventFromEventPusher(
addNewGroupUsersAddedEvent("group1", "org1", []string{"user1", "user2"}),
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user3", "user4"},
},
want: &domain.ObjectDetails{
ResourceOwner: "org1",
ID: "group1",
},
},
{
name: "failed to push events, error",
fields: fields{
eventstore: expectEventstore(
expectFilter( // to get the group write model
eventFromEventPusher(
addNewGroupEvent("group1", "org1"),
),
eventFromEventPusher(
addNewGroupUsersAddedEvent("group1", "org1", []string{"user1", "user2"}),
),
),
expectPushFailed(
pushErr,
group.NewGroupUsersRemovedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user1"},
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
groupID: "group1",
userIDs: []string{"user1"},
},
wantErr: func(err error) bool {
return errors.Is(err, pushErr)
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
c := &Commands{
eventstore: tt.fields.eventstore(t),
checkPermission: tt.fields.checkPermission,
}
got, err := c.RemoveUsersFromGroup(context.Background(), tt.args.groupID, tt.args.userIDs)
if tt.wantErr != nil {
require.True(t, tt.wantErr(err))
return
}
assertObjectDetails(t, tt.want, got)
})
}
}
func addNewGroupUsersAddedEvent(groupID, orgID string, userIds []string) *group.GroupUsersAddedEvent {
return group.NewGroupUsersAddedEvent(context.Background(),
&group.NewAggregate(groupID, orgID).Aggregate,
userIds,
)
}
func addNewUserEvent(userID, orgID string) *user.HumanAddedEvent {
return user.NewHumanAddedEvent(context.Background(),
&user.NewAggregate(userID, orgID).Aggregate,
"username",
"firstname",
"lastname",
"nickname",
"displayname",
AllowedLanguage,
domain.GenderUnspecified,
"[email protected]",
true,
)
}
+8
View File
@@ -172,3 +172,11 @@ func (c *Commands) checkPermissionUpdateGroup(ctx context.Context, resourceOwner
func (c *Commands) checkPermissionDeleteGroup(ctx context.Context, resourceOwner, groupID string) error {
return c.newPermissionCheck(ctx, domain.PermissionGroupDelete, group.AggregateType)(resourceOwner, groupID)
}
func (c *Commands) checkPermissionAddUserToGroup(ctx context.Context, resourceOwner, groupID string) error {
return c.newPermissionCheck(ctx, domain.PermissionGroupUserWrite, group.AggregateType)(resourceOwner, groupID)
}
func (c *Commands) checkPermissionRemoveUserFromGroup(ctx context.Context, resourceOwner, groupID string) error {
return c.newPermissionCheck(ctx, domain.PermissionGroupUserDelete, group.AggregateType)(resourceOwner, groupID)
}
+10 -1
View File
@@ -177,7 +177,7 @@ func (c *Commands) UnlockUser(ctx context.Context, userID, resourceOwner string)
return writeModelToObjectDetails(&existingUser.WriteModel), nil
}
func (c *Commands) RemoveUser(ctx context.Context, userID, resourceOwner string, cascadingUserMemberships []*CascadingMembership, cascadingGrantIDs ...string) (*domain.ObjectDetails, error) {
func (c *Commands) RemoveUser(ctx context.Context, userID, resourceOwner string, cascadingUserMemberships []*CascadingMembership, cascadingGrantIDs, cascadingGroupIDs []string) (*domain.ObjectDetails, error) {
if userID == "" {
return nil, zerrors.ThrowInvalidArgument(nil, "COMMAND-2M0ds", "Errors.User.UserIDMissing")
}
@@ -219,6 +219,15 @@ func (c *Commands) RemoveUser(ctx context.Context, userID, resourceOwner string,
events = append(events, membershipEvents...)
}
// remove user from user groups
if len(cascadingGroupIDs) > 0 {
groupUserEvents, err := c.removeUserFromGroups(ctx, userID, cascadingGroupIDs, resourceOwner)
if err != nil {
return nil, err
}
events = append(events, groupUserEvents...)
}
pushedEvents, err := c.eventstore.Push(ctx, events...)
if err != nil {
return nil, err
+77 -1
View File
@@ -11,6 +11,7 @@ import (
"github.com/zitadel/zitadel/internal/command/preparation"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/repository/group"
"github.com/zitadel/zitadel/internal/repository/instance"
"github.com/zitadel/zitadel/internal/repository/org"
"github.com/zitadel/zitadel/internal/repository/project"
@@ -1157,6 +1158,7 @@ func TestCommandSide_RemoveUser(t *testing.T) {
userID string
cascadeUserMemberships []*CascadingMembership
cascadeUserGrants []string
cascadeUserGroups []string
}
)
type res struct {
@@ -1506,13 +1508,87 @@ func TestCommandSide_RemoveUser(t *testing.T) {
},
},
},
{
name: "remove user with user groups, ok",
fields: fields{
eventstore: expectEventstore(
expectFilter(
eventFromEventPusher(
user.NewHumanAddedEvent(context.Background(),
&user.NewAggregate("user1", "org1").Aggregate,
"username",
"firstname",
"lastname",
"nickname",
"displayname",
language.German,
domain.GenderUnspecified,
"[email protected]",
true,
),
),
eventFromEventPusher(
group.NewGroupUsersAddedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user1"},
),
),
eventFromEventPusher(
group.NewGroupUsersAddedEvent(context.Background(),
&group.NewAggregate("group2", "org1").Aggregate,
[]string{"user1"},
),
),
),
expectFilter(),
expectFilter(
eventFromEventPusher(
instance.NewDomainPolicyAddedEvent(context.Background(),
&user.NewAggregate("user1", "org1").Aggregate,
true,
true,
true,
),
),
),
expectFilterOrganizationSettings("org1", false, false),
expectPush(
user.NewUserRemovedEvent(context.Background(),
&user.NewAggregate("user1", "org1").Aggregate,
"username",
nil,
true,
),
group.NewGroupUsersRemovedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user1"},
),
group.NewGroupUsersRemovedEvent(context.Background(),
&group.NewAggregate("group2", "org1").Aggregate,
[]string{"user1"},
),
),
),
},
args: args{
ctx: context.Background(),
orgID: "org1",
userID: "user1",
cascadeUserGroups: []string{"group1", "group2"},
},
res: res{
want: &domain.ObjectDetails{
ResourceOwner: "org1",
},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
r := &Commands{
eventstore: tt.fields.eventstore(t),
}
got, err := r.RemoveUser(tt.args.ctx, tt.args.userID, tt.args.orgID, tt.args.cascadeUserMemberships, tt.args.cascadeUserGrants...)
got, err := r.RemoveUser(tt.args.ctx, tt.args.userID, tt.args.orgID, tt.args.cascadeUserMemberships, tt.args.cascadeUserGrants, tt.args.cascadeUserGroups)
if tt.res.err == nil {
assert.NoError(t, err)
} else if !tt.res.err(err) {
+10 -1
View File
@@ -128,7 +128,7 @@ func (c *Commands) userStateWriteModel(ctx context.Context, userID string) (writ
return writeModel, nil
}
func (c *Commands) RemoveUserV2(ctx context.Context, userID, resourceOwner string, cascadingUserMemberships []*CascadingMembership, cascadingGrantIDs ...string) (*domain.ObjectDetails, error) {
func (c *Commands) RemoveUserV2(ctx context.Context, userID, resourceOwner string, cascadingUserMemberships []*CascadingMembership, cascadingGrantIDs, cascadingGroupIDs []string) (*domain.ObjectDetails, error) {
if userID == "" {
return nil, zerrors.ThrowInvalidArgument(nil, "COMMAND-vaipl7s13l", "Errors.User.UserIDMissing")
}
@@ -171,6 +171,15 @@ func (c *Commands) RemoveUserV2(ctx context.Context, userID, resourceOwner strin
events = append(events, membershipEvents...)
}
// remove user from user groups
if len(cascadingGroupIDs) > 0 {
groupUserEvents, err := c.removeUserFromGroups(ctx, userID, cascadingGroupIDs, resourceOwner)
if err != nil {
return nil, err
}
events = append(events, groupUserEvents...)
}
pushedEvents, err := c.eventstore.Push(ctx, events...)
if err != nil {
return nil, err
+78 -1
View File
@@ -12,6 +12,7 @@ import (
"github.com/zitadel/zitadel/internal/api/authz"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/repository/group"
"github.com/zitadel/zitadel/internal/repository/org"
"github.com/zitadel/zitadel/internal/repository/user"
"github.com/zitadel/zitadel/internal/zerrors"
@@ -1099,6 +1100,7 @@ func TestCommandSide_RemoveUserV2(t *testing.T) {
userID string
cascadingMemberships []*CascadingMembership
grantIDs []string
groupIDs []string
}
)
type res struct {
@@ -1351,6 +1353,81 @@ func TestCommandSide_RemoveUserV2(t *testing.T) {
},
},
},
{
name: "remove user with user groups, ok",
fields: fields{
eventstore: expectEventstore(
expectFilter(
eventFromEventPusher(
user.NewHumanAddedEvent(ctx,
userAgg,
"username",
"firstname",
"lastname",
"nickname",
"displayname",
language.German,
domain.GenderUnspecified,
"[email protected]",
true,
),
),
eventFromEventPusher(
group.NewGroupUsersAddedEvent(context.Background(),
&group.NewAggregate("group1", "org1").Aggregate,
[]string{"user1"},
),
),
eventFromEventPusher(
group.NewGroupUsersAddedEvent(context.Background(),
&group.NewAggregate("group2", "org1").Aggregate,
[]string{"user1"},
),
),
),
expectFilter(
eventFromEventPusher(
org.NewDomainPolicyAddedEvent(context.Background(),
orgAgg,
true,
true,
true,
),
),
),
expectFilterOrganizationSettings("org1", false, false),
expectPush(
user.NewUserRemovedEvent(ctx,
userAgg,
"username",
nil,
true,
),
group.NewGroupUsersRemovedEvent(ctx,
&group.NewAggregate("group1", "").Aggregate,
[]string{"user1"},
),
group.NewGroupUsersRemovedEvent(ctx,
&group.NewAggregate("group2", "").Aggregate,
[]string{"user1"},
),
),
),
checkPermission: newMockPermissionCheckAllowed(),
},
args: args{
userID: "user1",
groupIDs: []string{
"group1",
"group2",
},
},
res: res{
want: &domain.ObjectDetails{
ResourceOwner: "org1",
},
},
},
{
name: "remove self, permission denied",
fields: fields{
@@ -1389,7 +1466,7 @@ func TestCommandSide_RemoveUserV2(t *testing.T) {
checkPermission: tt.fields.checkPermission,
}
got, err := r.RemoveUserV2(ctx, tt.args.userID, "", tt.args.cascadingMemberships, tt.args.grantIDs...)
got, err := r.RemoveUserV2(ctx, tt.args.userID, "", tt.args.cascadingMemberships, tt.args.grantIDs, tt.args.groupIDs)
if tt.res.err == nil {
assert.NoError(t, err)
}