fix: rename iam to instance (#3345)

* fix: rename iam command side to instance

* fix: rename iam command side to instance

* fix: rename iam command side to instance

* fix: rename iam command side to instance

* fix: rename orgiampolicy to domain policy

* fix: merge conflicts

* fix: protos

* fix: md files

* implement deprecated org iam policy again

Co-authored-by: Livio Amstutz <[email protected]>
This commit is contained in:
Fabi
2022-03-24 16:21:34 +00:00
committed by GitHub
co-authored by Livio Amstutz
parent 504fe5b761
commit 9d4f296c62
274 changed files with 12073 additions and 11853 deletions
+1 -1
View File
@@ -13,7 +13,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/id"
"github.com/caos/zitadel/internal/repository/action"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
iam_repo "github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/keypair"
"github.com/caos/zitadel/internal/repository/org"
proj_repo "github.com/caos/zitadel/internal/repository/project"
+3 -3
View File
@@ -7,7 +7,7 @@ import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/org"
)
@@ -1098,9 +1098,9 @@ func (c *Commands) createCustomLoginTextEvent(ctx context.Context, agg *eventsto
}
if defaultText {
if newText != "" {
return iam.NewCustomTextSetEvent(ctx, agg, domain.LoginCustomText, textKey, newText, lang)
return instance.NewCustomTextSetEvent(ctx, agg, domain.LoginCustomText, textKey, newText, lang)
}
return iam.NewCustomTextRemovedEvent(ctx, agg, domain.LoginCustomText, textKey, lang)
return instance.NewCustomTextRemovedEvent(ctx, agg, domain.LoginCustomText, textKey, lang)
}
if newText != "" {
return org.NewCustomTextSetEvent(ctx, agg, domain.LoginCustomText, textKey, newText, lang)
@@ -4,7 +4,7 @@ import (
"context"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/org"
)
@@ -25,7 +25,7 @@ func (rm *ExistingLabelPoliciesReadModel) AppendEvents(events ...eventstore.Even
func (rm *ExistingLabelPoliciesReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *iam.LabelPolicyAddedEvent,
case *instance.LabelPolicyAddedEvent,
*org.LabelPolicyAddedEvent:
rm.aggregateIDs = append(rm.aggregateIDs, e.Aggregate().ID)
case *org.LabelPolicyRemovedEvent:
@@ -44,8 +44,8 @@ func (rm *ExistingLabelPoliciesReadModel) Reduce() error {
func (rm *ExistingLabelPoliciesReadModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
AddQuery().
AggregateTypes(iam.AggregateType).
EventTypes(iam.LabelPolicyAddedEventType).
AggregateTypes(instance.AggregateType).
EventTypes(instance.LabelPolicyAddedEventType).
Or().
AggregateTypes(org.AggregateType).
EventTypes(
File diff suppressed because it is too large Load Diff
-123
View File
@@ -1,123 +0,0 @@
package command
import (
"context"
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"golang.org/x/text/language"
)
func (c *Commands) SetDefaultMessageText(ctx context.Context, messageText *domain.CustomMessageText) (*domain.ObjectDetails, error) {
iamAgg := iam.NewAggregate()
events, existingMessageText, err := c.setDefaultMessageText(ctx, &iamAgg.Aggregate, messageText)
if err != nil {
return nil, err
}
pushedEvents, err := c.eventstore.Push(ctx, events...)
if err != nil {
return nil, err
}
err = AppendAndReduce(existingMessageText, pushedEvents...)
if err != nil {
return nil, err
}
return writeModelToObjectDetails(&existingMessageText.WriteModel), nil
}
func (c *Commands) setDefaultMessageText(ctx context.Context, iamAgg *eventstore.Aggregate, msg *domain.CustomMessageText) ([]eventstore.Command, *IAMCustomMessageTextReadModel, error) {
if !msg.IsValid() {
return nil, nil, caos_errs.ThrowInvalidArgument(nil, "IAM-kd9fs", "Errors.CustomMessageText.Invalid")
}
existingMessageText, err := c.defaultCustomMessageTextWriteModelByID(ctx, msg.MessageTextType, msg.Language)
if err != nil {
return nil, nil, err
}
events := make([]eventstore.Command, 0)
if existingMessageText.Greeting != msg.Greeting {
if msg.Greeting != "" {
events = append(events, iam.NewCustomTextSetEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageGreeting, msg.Greeting, msg.Language))
} else {
events = append(events, iam.NewCustomTextRemovedEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageGreeting, msg.Language))
}
}
if existingMessageText.Subject != msg.Subject {
if msg.Subject != "" {
events = append(events, iam.NewCustomTextSetEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageSubject, msg.Subject, msg.Language))
} else {
events = append(events, iam.NewCustomTextRemovedEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageSubject, msg.Language))
}
}
if existingMessageText.Title != msg.Title {
if msg.Title != "" {
events = append(events, iam.NewCustomTextSetEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageTitle, msg.Title, msg.Language))
} else {
events = append(events, iam.NewCustomTextRemovedEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageTitle, msg.Language))
}
}
if existingMessageText.PreHeader != msg.PreHeader {
if msg.PreHeader != "" {
events = append(events, iam.NewCustomTextSetEvent(ctx, iamAgg, msg.MessageTextType, domain.MessagePreHeader, msg.PreHeader, msg.Language))
} else {
events = append(events, iam.NewCustomTextRemovedEvent(ctx, iamAgg, msg.MessageTextType, domain.MessagePreHeader, msg.Language))
}
}
if existingMessageText.Text != msg.Text {
if msg.Text != "" {
events = append(events, iam.NewCustomTextSetEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageText, msg.Text, msg.Language))
} else {
events = append(events, iam.NewCustomTextRemovedEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageText, msg.Language))
}
}
if existingMessageText.ButtonText != msg.ButtonText {
if msg.ButtonText != "" {
events = append(events, iam.NewCustomTextSetEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageButtonText, msg.ButtonText, msg.Language))
} else {
events = append(events, iam.NewCustomTextRemovedEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageButtonText, msg.Language))
}
}
if existingMessageText.FooterText != msg.FooterText {
if msg.FooterText != "" {
events = append(events, iam.NewCustomTextSetEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageFooterText, msg.FooterText, msg.Language))
} else {
events = append(events, iam.NewCustomTextRemovedEvent(ctx, iamAgg, msg.MessageTextType, domain.MessageFooterText, msg.Language))
}
}
return events, existingMessageText, nil
}
func (c *Commands) RemoveIAMMessageTexts(ctx context.Context, messageTextType string, lang language.Tag) (*domain.ObjectDetails, error) {
if messageTextType == "" || lang == language.Und {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-fjw9b", "Errors.CustomMessageText.Invalid")
}
customText, err := c.defaultCustomMessageTextWriteModelByID(ctx, messageTextType, lang)
if err != nil {
return nil, err
}
if customText.State == domain.PolicyStateUnspecified || customText.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "Org-fju90", "Errors.CustomMessageText.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&customText.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam.NewCustomTextTemplateRemovedEvent(ctx, iamAgg, messageTextType, lang))
if err != nil {
return nil, err
}
err = AppendAndReduce(customText, pushedEvents...)
if err != nil {
return nil, err
}
return writeModelToObjectDetails(&customText.WriteModel), nil
}
func (c *Commands) defaultCustomMessageTextWriteModelByID(ctx context.Context, messageType string, lang language.Tag) (*IAMCustomMessageTextReadModel, error) {
writeModel := NewIAMCustomMessageTextWriteModel(messageType, lang)
err := c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
}
return writeModel, nil
}
-142
View File
@@ -1,142 +0,0 @@
package command
import (
"context"
"reflect"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/errors"
caos_errs "github.com/caos/zitadel/internal/errors"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddIAMMember(ctx context.Context, member *domain.Member) (*domain.Member, error) {
if member.UserID == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-Mf83b", "Errors.IAM.MemberInvalid")
}
addedMember := NewIAMMemberWriteModel(member.UserID)
iamAgg := IAMAggregateFromWriteModel(&addedMember.MemberWriteModel.WriteModel)
err := c.checkUserExists(ctx, addedMember.UserID, "")
if err != nil {
return nil, caos_errs.ThrowPreconditionFailed(err, "IAM-5N9vs", "Errors.User.NotFound")
}
event, err := c.addIAMMember(ctx, iamAgg, addedMember, member)
if err != nil {
return nil, err
}
pushedEvents, err := c.eventstore.Push(ctx, event)
if err != nil {
return nil, err
}
err = AppendAndReduce(addedMember, pushedEvents...)
if err != nil {
return nil, err
}
return memberWriteModelToMember(&addedMember.MemberWriteModel), nil
}
func (c *Commands) addIAMMember(ctx context.Context, iamAgg *eventstore.Aggregate, addedMember *IAMMemberWriteModel, member *domain.Member) (eventstore.Command, error) {
if !member.IsIAMValid() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-GR34U", "Errors.IAM.MemberInvalid")
}
if len(domain.CheckForInvalidRoles(member.Roles, domain.IAMRolePrefix, c.zitadelRoles)) > 0 {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-4m0fS", "Errors.IAM.MemberInvalid")
}
err := c.eventstore.FilterToQueryReducer(ctx, addedMember)
if err != nil {
return nil, err
}
if addedMember.State == domain.MemberStateActive {
return nil, errors.ThrowAlreadyExists(nil, "IAM-sdgQ4", "Errors.IAM.Member.AlreadyExists")
}
return iam_repo.NewMemberAddedEvent(ctx, iamAgg, member.UserID, member.Roles...), nil
}
//ChangeIAMMember updates an existing member
func (c *Commands) ChangeIAMMember(ctx context.Context, member *domain.Member) (*domain.Member, error) {
if !member.IsIAMValid() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-LiaZi", "Errors.IAM.MemberInvalid")
}
if len(domain.CheckForInvalidRoles(member.Roles, domain.IAMRolePrefix, c.zitadelRoles)) > 0 {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-3m9fs", "Errors.IAM.MemberInvalid")
}
existingMember, err := c.iamMemberWriteModelByID(ctx, member.UserID)
if err != nil {
return nil, err
}
if reflect.DeepEqual(existingMember.Roles, member.Roles) {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-LiaZi", "Errors.IAM.Member.RolesNotChanged")
}
iamAgg := IAMAggregateFromWriteModel(&existingMember.MemberWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewMemberChangedEvent(ctx, iamAgg, member.UserID, member.Roles...))
if err != nil {
return nil, err
}
err = AppendAndReduce(existingMember, pushedEvents...)
if err != nil {
return nil, err
}
return memberWriteModelToMember(&existingMember.MemberWriteModel), nil
}
func (c *Commands) RemoveIAMMember(ctx context.Context, userID string) (*domain.ObjectDetails, error) {
if userID == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-LiaZi", "Errors.IDMissing")
}
memberWriteModel, err := c.iamMemberWriteModelByID(ctx, userID)
if err != nil && !errors.IsNotFound(err) {
return nil, err
}
if errors.IsNotFound(err) {
return nil, nil
}
iamAgg := IAMAggregateFromWriteModel(&memberWriteModel.MemberWriteModel.WriteModel)
removeEvent := c.removeIAMMember(ctx, iamAgg, userID, false)
pushedEvents, err := c.eventstore.Push(ctx, removeEvent)
if err != nil {
return nil, err
}
err = AppendAndReduce(memberWriteModel, pushedEvents...)
if err != nil {
return nil, err
}
return writeModelToObjectDetails(&memberWriteModel.MemberWriteModel.WriteModel), nil
}
func (c *Commands) removeIAMMember(ctx context.Context, iamAgg *eventstore.Aggregate, userID string, cascade bool) eventstore.Command {
if cascade {
return iam_repo.NewMemberCascadeRemovedEvent(
ctx,
iamAgg,
userID)
} else {
return iam_repo.NewMemberRemovedEvent(ctx, iamAgg, userID)
}
}
func (c *Commands) iamMemberWriteModelByID(ctx context.Context, userID string) (member *IAMMemberWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMMemberWriteModel(userID)
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
}
if writeModel.State == domain.MemberStateUnspecified || writeModel.State == domain.MemberStateRemoved {
return nil, errors.ThrowNotFound(nil, "IAM-D8JxR", "Errors.NotFound")
}
return writeModel, nil
}
-92
View File
@@ -1,92 +0,0 @@
package command
import (
"context"
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddDefaultOrgIAMPolicy(ctx context.Context, policy *domain.OrgIAMPolicy) (*domain.OrgIAMPolicy, error) {
addedPolicy := NewIAMOrgIAMPolicyWriteModel()
iamAgg := IAMAggregateFromWriteModel(&addedPolicy.WriteModel)
event, err := c.addDefaultOrgIAMPolicy(ctx, iamAgg, addedPolicy, policy)
if err != nil {
return nil, err
}
pushedEvents, err := c.eventstore.Push(ctx, event)
if err != nil {
return nil, err
}
err = AppendAndReduce(addedPolicy, pushedEvents...)
if err != nil {
return nil, err
}
return writeModelToOrgIAMPolicy(addedPolicy), nil
}
func (c *Commands) addDefaultOrgIAMPolicy(ctx context.Context, iamAgg *eventstore.Aggregate, addedPolicy *IAMOrgIAMPolicyWriteModel, policy *domain.OrgIAMPolicy) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, addedPolicy)
if err != nil {
return nil, err
}
if addedPolicy.State == domain.PolicyStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-Lk0dS", "Errors.IAM.OrgIAMPolicy.AlreadyExists")
}
return iam_repo.NewOrgIAMPolicyAddedEvent(ctx, iamAgg, policy.UserLoginMustBeDomain), nil
}
func (c *Commands) ChangeDefaultOrgIAMPolicy(ctx context.Context, policy *domain.OrgIAMPolicy) (*domain.OrgIAMPolicy, error) {
existingPolicy, err := c.defaultOrgIAMPolicyWriteModelByID(ctx)
if err != nil {
return nil, err
}
if !existingPolicy.State.Exists() {
return nil, caos_errs.ThrowNotFound(nil, "IAM-0Pl0d", "Errors.IAM.OrgIAMPolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.PolicyOrgIAMWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, iamAgg, policy.UserLoginMustBeDomain)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
}
pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
if err != nil {
return nil, err
}
err = AppendAndReduce(existingPolicy, pushedEvents...)
if err != nil {
return nil, err
}
return writeModelToOrgIAMPolicy(existingPolicy), nil
}
func (c *Commands) getDefaultOrgIAMPolicy(ctx context.Context) (*domain.OrgIAMPolicy, error) {
policyWriteModel, err := c.defaultOrgIAMPolicyWriteModelByID(ctx)
if err != nil {
return nil, err
}
if !policyWriteModel.State.Exists() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-3n8fs", "Errors.IAM.PasswordComplexityPolicy.NotFound")
}
policy := writeModelToOrgIAMPolicy(policyWriteModel)
policy.Default = true
return policy, nil
}
func (c *Commands) defaultOrgIAMPolicyWriteModelByID(ctx context.Context) (policy *IAMOrgIAMPolicyWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMOrgIAMPolicyWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
}
return writeModel, nil
}
@@ -1,71 +0,0 @@
package command
import (
"context"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMOrgIAMPolicyWriteModel struct {
PolicyOrgIAMWriteModel
}
func NewIAMOrgIAMPolicyWriteModel() *IAMOrgIAMPolicyWriteModel {
return &IAMOrgIAMPolicyWriteModel{
PolicyOrgIAMWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
ResourceOwner: domain.IAMID,
},
},
}
}
func (wm *IAMOrgIAMPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.OrgIAMPolicyAddedEvent:
wm.PolicyOrgIAMWriteModel.AppendEvents(&e.OrgIAMPolicyAddedEvent)
case *iam.OrgIAMPolicyChangedEvent:
wm.PolicyOrgIAMWriteModel.AppendEvents(&e.OrgIAMPolicyChangedEvent)
}
}
}
func (wm *IAMOrgIAMPolicyWriteModel) Reduce() error {
return wm.PolicyOrgIAMWriteModel.Reduce()
}
func (wm *IAMOrgIAMPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateIDs(wm.PolicyOrgIAMWriteModel.AggregateID).
EventTypes(
iam.OrgIAMPolicyAddedEventType,
iam.OrgIAMPolicyChangedEventType).
Builder()
}
func (wm *IAMOrgIAMPolicyWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
userLoginMustBeDomain bool) (*iam.OrgIAMPolicyChangedEvent, bool) {
changes := make([]policy.OrgIAMPolicyChanges, 0)
if wm.UserLoginMustBeDomain != userLoginMustBeDomain {
changes = append(changes, policy.ChangeUserLoginMustBeDomain(userLoginMustBeDomain))
}
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewOrgIAMPolicyChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
return changedEvent, true
}
@@ -6,16 +6,16 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMPasswordAgePolicyWriteModel struct {
type InstancePasswordAgePolicyWriteModel struct {
PasswordAgePolicyWriteModel
}
func NewIAMPasswordAgePolicyWriteModel() *IAMPasswordAgePolicyWriteModel {
return &IAMPasswordAgePolicyWriteModel{
func NewInstancePasswordAgePolicyWriteModel() *InstancePasswordAgePolicyWriteModel {
return &InstancePasswordAgePolicyWriteModel{
PasswordAgePolicyWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -25,38 +25,38 @@ func NewIAMPasswordAgePolicyWriteModel() *IAMPasswordAgePolicyWriteModel {
}
}
func (wm *IAMPasswordAgePolicyWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstancePasswordAgePolicyWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.PasswordAgePolicyAddedEvent:
case *instance.PasswordAgePolicyAddedEvent:
wm.PasswordAgePolicyWriteModel.AppendEvents(&e.PasswordAgePolicyAddedEvent)
case *iam.PasswordAgePolicyChangedEvent:
case *instance.PasswordAgePolicyChangedEvent:
wm.PasswordAgePolicyWriteModel.AppendEvents(&e.PasswordAgePolicyChangedEvent)
}
}
}
func (wm *IAMPasswordAgePolicyWriteModel) Reduce() error {
func (wm *InstancePasswordAgePolicyWriteModel) Reduce() error {
return wm.PasswordAgePolicyWriteModel.Reduce()
}
func (wm *IAMPasswordAgePolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstancePasswordAgePolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.PasswordAgePolicyWriteModel.AggregateID).
EventTypes(
iam.PasswordAgePolicyAddedEventType,
iam.PasswordAgePolicyChangedEventType).
instance.PasswordAgePolicyAddedEventType,
instance.PasswordAgePolicyChangedEventType).
Builder()
}
func (wm *IAMPasswordAgePolicyWriteModel) NewChangedEvent(
func (wm *InstancePasswordAgePolicyWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
expireWarnDays,
maxAgeDays uint64) (*iam.PasswordAgePolicyChangedEvent, bool) {
maxAgeDays uint64) (*instance.PasswordAgePolicyChangedEvent, bool) {
changes := make([]policy.PasswordAgePolicyChanges, 0)
if wm.ExpireWarnDays != expireWarnDays {
changes = append(changes, policy.ChangeExpireWarnDays(expireWarnDays))
@@ -67,7 +67,7 @@ func (wm *IAMPasswordAgePolicyWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewPasswordAgePolicyChangedEvent(ctx, aggregate, changes)
changedEvent, err := instance.NewPasswordAgePolicyChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
@@ -6,22 +6,22 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
"golang.org/x/text/language"
)
//TODO: private as soon as setup uses query
func (c *Commands) GetIAM(ctx context.Context) (*domain.IAM, error) {
iamWriteModel := NewIAMWriteModel()
func (c *Commands) GetInstance(ctx context.Context) (*domain.Instance, error) {
iamWriteModel := NewInstanceWriteModel()
err := c.eventstore.FilterToQueryReducer(ctx, iamWriteModel)
if err != nil {
return nil, err
}
return writeModelToIAM(iamWriteModel), nil
return writeModelToInstance(iamWriteModel), nil
}
func (c *Commands) setGlobalOrg(ctx context.Context, iamAgg *eventstore.Aggregate, iamWriteModel *IAMWriteModel, orgID string) (eventstore.Command, error) {
func (c *Commands) setGlobalOrg(ctx context.Context, iamAgg *eventstore.Aggregate, iamWriteModel *InstanceWriteModel, orgID string) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, iamWriteModel)
if err != nil {
return nil, err
@@ -29,10 +29,10 @@ func (c *Commands) setGlobalOrg(ctx context.Context, iamAgg *eventstore.Aggregat
if iamWriteModel.GlobalOrgID != "" {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-HGG24", "Errors.IAM.GlobalOrgAlreadySet")
}
return iam.NewGlobalOrgSetEventEvent(ctx, iamAgg, orgID), nil
return instance.NewGlobalOrgSetEventEvent(ctx, iamAgg, orgID), nil
}
func (c *Commands) setIAMProject(ctx context.Context, iamAgg *eventstore.Aggregate, iamWriteModel *IAMWriteModel, projectID string) (eventstore.Command, error) {
func (c *Commands) setIAMProject(ctx context.Context, iamAgg *eventstore.Aggregate, iamWriteModel *InstanceWriteModel, projectID string) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, iamWriteModel)
if err != nil {
return nil, err
@@ -40,7 +40,7 @@ func (c *Commands) setIAMProject(ctx context.Context, iamAgg *eventstore.Aggrega
if iamWriteModel.ProjectID != "" {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-EGbw2", "Errors.IAM.IAMProjectAlreadySet")
}
return iam.NewIAMProjectSetEvent(ctx, iamAgg, projectID), nil
return instance.NewIAMProjectSetEvent(ctx, iamAgg, projectID), nil
}
func (c *Commands) SetDefaultLanguage(ctx context.Context, language language.Tag) (*domain.ObjectDetails, error) {
@@ -48,8 +48,8 @@ func (c *Commands) SetDefaultLanguage(ctx context.Context, language language.Tag
if err != nil {
return nil, err
}
iamAgg := IAMAggregateFromWriteModel(&iamWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam.NewDefaultLanguageSetEvent(ctx, iamAgg, language))
iamAgg := InstanceAggregateFromWriteModel(&iamWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewDefaultLanguageSetEvent(ctx, iamAgg, language))
if err != nil {
return nil, err
}
@@ -60,11 +60,11 @@ func (c *Commands) SetDefaultLanguage(ctx context.Context, language language.Tag
return writeModelToObjectDetails(&iamWriteModel.WriteModel), nil
}
func (c *Commands) getIAMWriteModel(ctx context.Context) (_ *IAMWriteModel, err error) {
func (c *Commands) getIAMWriteModel(ctx context.Context) (_ *InstanceWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMWriteModel()
writeModel := NewInstanceWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -15,8 +15,8 @@ func writeModelToObjectRoot(writeModel eventstore.WriteModel) models.ObjectRoot
}
}
func writeModelToIAM(wm *IAMWriteModel) *domain.IAM {
return &domain.IAM{
func writeModelToInstance(wm *InstanceWriteModel) *domain.Instance {
return &domain.Instance{
ObjectRoot: writeModelToObjectRoot(wm.WriteModel),
SetUpStarted: wm.SetUpStarted,
SetUpDone: wm.SetUpDone,
@@ -74,9 +74,9 @@ func writeModelToMailTemplate(wm *MailTemplateWriteModel) *domain.MailTemplate {
}
}
func writeModelToOrgIAMPolicy(wm *IAMOrgIAMPolicyWriteModel) *domain.OrgIAMPolicy {
return &domain.OrgIAMPolicy{
ObjectRoot: writeModelToObjectRoot(wm.PolicyOrgIAMWriteModel.WriteModel),
func writeModelToDomainPolicy(wm *InstanceDomainPolicyWriteModel) *domain.DomainPolicy {
return &domain.DomainPolicy{
ObjectRoot: writeModelToObjectRoot(wm.PolicyDomainWriteModel.WriteModel),
UserLoginMustBeDomain: wm.UserLoginMustBeDomain,
}
}
@@ -8,12 +8,12 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
func (c *Commands) SetCustomIAMLoginText(ctx context.Context, loginText *domain.CustomLoginText) (*domain.ObjectDetails, error) {
iamAgg := iam.NewAggregate()
events, existingMailText, err := c.setCustomIAMLoginText(ctx, &iamAgg.Aggregate, loginText)
func (c *Commands) SetCustomInstanceLoginText(ctx context.Context, loginText *domain.CustomLoginText) (*domain.ObjectDetails, error) {
iamAgg := instance.NewAggregate()
events, existingMailText, err := c.setCustomInstanceLoginText(ctx, &iamAgg.Aggregate, loginText)
if err != nil {
return nil, err
}
@@ -28,7 +28,7 @@ func (c *Commands) SetCustomIAMLoginText(ctx context.Context, loginText *domain.
return writeModelToObjectDetails(&existingMailText.WriteModel), nil
}
func (c *Commands) RemoveCustomIAMLoginTexts(ctx context.Context, lang language.Tag) (*domain.ObjectDetails, error) {
func (c *Commands) RemoveCustomInstanceLoginTexts(ctx context.Context, lang language.Tag) (*domain.ObjectDetails, error) {
if lang == language.Und {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-Gfbg3", "Errors.CustomText.Invalid")
}
@@ -39,8 +39,8 @@ func (c *Commands) RemoveCustomIAMLoginTexts(ctx context.Context, lang language.
if customText.State == domain.PolicyStateUnspecified || customText.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-fru44", "Errors.CustomText.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&customText.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam.NewCustomTextTemplateRemovedEvent(ctx, iamAgg, domain.LoginCustomText, lang))
iamAgg := InstanceAggregateFromWriteModel(&customText.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewCustomTextTemplateRemovedEvent(ctx, iamAgg, domain.LoginCustomText, lang))
err = AppendAndReduce(customText, pushedEvents...)
if err != nil {
return nil, err
@@ -48,21 +48,21 @@ func (c *Commands) RemoveCustomIAMLoginTexts(ctx context.Context, lang language.
return writeModelToObjectDetails(&customText.WriteModel), nil
}
func (c *Commands) setCustomIAMLoginText(ctx context.Context, iamAgg *eventstore.Aggregate, text *domain.CustomLoginText) ([]eventstore.Command, *IAMCustomLoginTextReadModel, error) {
func (c *Commands) setCustomInstanceLoginText(ctx context.Context, instanceAgg *eventstore.Aggregate, text *domain.CustomLoginText) ([]eventstore.Command, *InstanceCustomLoginTextReadModel, error) {
if !text.IsValid() {
return nil, nil, caos_errs.ThrowInvalidArgument(nil, "IAM-kd9fs", "Errors.CustomText.Invalid")
return nil, nil, caos_errs.ThrowInvalidArgument(nil, "Instance-kd9fs", "Errors.CustomText.Invalid")
}
existingLoginText, err := c.defaultLoginTextWriteModelByID(ctx, text.Language)
if err != nil {
return nil, nil, err
}
events := c.createAllLoginTextEvents(ctx, iamAgg, &existingLoginText.CustomLoginTextReadModel, text, true)
events := c.createAllLoginTextEvents(ctx, instanceAgg, &existingLoginText.CustomLoginTextReadModel, text, true)
return events, existingLoginText, nil
}
func (c *Commands) defaultLoginTextWriteModelByID(ctx context.Context, lang language.Tag) (*IAMCustomLoginTextReadModel, error) {
writeModel := NewIAMCustomLoginTextReadModel(lang)
func (c *Commands) defaultLoginTextWriteModelByID(ctx context.Context, lang language.Tag) (*InstanceCustomLoginTextReadModel, error) {
writeModel := NewInstanceCustomLoginTextReadModel(lang)
err := c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -5,15 +5,15 @@ import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMCustomLoginTextReadModel struct {
type InstanceCustomLoginTextReadModel struct {
CustomLoginTextReadModel
}
func NewIAMCustomLoginTextReadModel(lang language.Tag) *IAMCustomLoginTextReadModel {
return &IAMCustomLoginTextReadModel{
func NewInstanceCustomLoginTextReadModel(lang language.Tag) *InstanceCustomLoginTextReadModel {
return &InstanceCustomLoginTextReadModel{
CustomLoginTextReadModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -24,32 +24,32 @@ func NewIAMCustomLoginTextReadModel(lang language.Tag) *IAMCustomLoginTextReadMo
}
}
func (wm *IAMCustomLoginTextReadModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceCustomLoginTextReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.CustomTextSetEvent:
case *instance.CustomTextSetEvent:
wm.CustomLoginTextReadModel.AppendEvents(&e.CustomTextSetEvent)
case *iam.CustomTextRemovedEvent:
case *instance.CustomTextRemovedEvent:
wm.CustomLoginTextReadModel.AppendEvents(&e.CustomTextRemovedEvent)
case *iam.CustomTextTemplateRemovedEvent:
case *instance.CustomTextTemplateRemovedEvent:
wm.CustomLoginTextReadModel.AppendEvents(&e.CustomTextTemplateRemovedEvent)
}
}
}
func (wm *IAMCustomLoginTextReadModel) Reduce() error {
func (wm *InstanceCustomLoginTextReadModel) Reduce() error {
return wm.CustomLoginTextReadModel.Reduce()
}
func (wm *IAMCustomLoginTextReadModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceCustomLoginTextReadModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateIDs(wm.CustomLoginTextReadModel.AggregateID).
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
EventTypes(
iam.CustomTextSetEventType,
iam.CustomTextRemovedEventType,
iam.CustomTextTemplateRemovedEventType).
instance.CustomTextSetEventType,
instance.CustomTextRemovedEventType,
instance.CustomTextTemplateRemovedEventType).
Builder()
}
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,123 @@
package command
import (
"context"
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/instance"
"golang.org/x/text/language"
)
func (c *Commands) SetDefaultMessageText(ctx context.Context, messageText *domain.CustomMessageText) (*domain.ObjectDetails, error) {
instanceAgg := instance.NewAggregate()
events, existingMessageText, err := c.setDefaultMessageText(ctx, &instanceAgg.Aggregate, messageText)
if err != nil {
return nil, err
}
pushedEvents, err := c.eventstore.Push(ctx, events...)
if err != nil {
return nil, err
}
err = AppendAndReduce(existingMessageText, pushedEvents...)
if err != nil {
return nil, err
}
return writeModelToObjectDetails(&existingMessageText.WriteModel), nil
}
func (c *Commands) setDefaultMessageText(ctx context.Context, instanceAgg *eventstore.Aggregate, msg *domain.CustomMessageText) ([]eventstore.Command, *InstanceCustomMessageTextReadModel, error) {
if !msg.IsValid() {
return nil, nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-kd9fs", "Errors.CustomMessageText.Invalid")
}
existingMessageText, err := c.defaultCustomMessageTextWriteModelByID(ctx, msg.MessageTextType, msg.Language)
if err != nil {
return nil, nil, err
}
events := make([]eventstore.Command, 0)
if existingMessageText.Greeting != msg.Greeting {
if msg.Greeting != "" {
events = append(events, instance.NewCustomTextSetEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageGreeting, msg.Greeting, msg.Language))
} else {
events = append(events, instance.NewCustomTextRemovedEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageGreeting, msg.Language))
}
}
if existingMessageText.Subject != msg.Subject {
if msg.Subject != "" {
events = append(events, instance.NewCustomTextSetEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageSubject, msg.Subject, msg.Language))
} else {
events = append(events, instance.NewCustomTextRemovedEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageSubject, msg.Language))
}
}
if existingMessageText.Title != msg.Title {
if msg.Title != "" {
events = append(events, instance.NewCustomTextSetEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageTitle, msg.Title, msg.Language))
} else {
events = append(events, instance.NewCustomTextRemovedEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageTitle, msg.Language))
}
}
if existingMessageText.PreHeader != msg.PreHeader {
if msg.PreHeader != "" {
events = append(events, instance.NewCustomTextSetEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessagePreHeader, msg.PreHeader, msg.Language))
} else {
events = append(events, instance.NewCustomTextRemovedEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessagePreHeader, msg.Language))
}
}
if existingMessageText.Text != msg.Text {
if msg.Text != "" {
events = append(events, instance.NewCustomTextSetEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageText, msg.Text, msg.Language))
} else {
events = append(events, instance.NewCustomTextRemovedEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageText, msg.Language))
}
}
if existingMessageText.ButtonText != msg.ButtonText {
if msg.ButtonText != "" {
events = append(events, instance.NewCustomTextSetEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageButtonText, msg.ButtonText, msg.Language))
} else {
events = append(events, instance.NewCustomTextRemovedEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageButtonText, msg.Language))
}
}
if existingMessageText.FooterText != msg.FooterText {
if msg.FooterText != "" {
events = append(events, instance.NewCustomTextSetEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageFooterText, msg.FooterText, msg.Language))
} else {
events = append(events, instance.NewCustomTextRemovedEvent(ctx, instanceAgg, msg.MessageTextType, domain.MessageFooterText, msg.Language))
}
}
return events, existingMessageText, nil
}
func (c *Commands) RemoveInstanceMessageTexts(ctx context.Context, messageTextType string, lang language.Tag) (*domain.ObjectDetails, error) {
if messageTextType == "" || lang == language.Und {
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-fjw9b", "Errors.CustomMessageText.Invalid")
}
customText, err := c.defaultCustomMessageTextWriteModelByID(ctx, messageTextType, lang)
if err != nil {
return nil, err
}
if customText.State == domain.PolicyStateUnspecified || customText.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-fju90", "Errors.CustomMessageText.NotFound")
}
instanceAgg := InstanceAggregateFromWriteModel(&customText.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewCustomTextTemplateRemovedEvent(ctx, instanceAgg, messageTextType, lang))
if err != nil {
return nil, err
}
err = AppendAndReduce(customText, pushedEvents...)
if err != nil {
return nil, err
}
return writeModelToObjectDetails(&customText.WriteModel), nil
}
func (c *Commands) defaultCustomMessageTextWriteModelByID(ctx context.Context, messageType string, lang language.Tag) (*InstanceCustomMessageTextReadModel, error) {
writeModel := NewInstanceCustomMessageTextWriteModel(messageType, lang)
err := c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
}
return writeModel, nil
}
@@ -5,15 +5,15 @@ import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMCustomMessageTextReadModel struct {
type InstanceCustomMessageTextReadModel struct {
CustomMessageTextReadModel
}
func NewIAMCustomMessageTextWriteModel(messageTextType string, lang language.Tag) *IAMCustomMessageTextReadModel {
return &IAMCustomMessageTextReadModel{
func NewInstanceCustomMessageTextWriteModel(messageTextType string, lang language.Tag) *InstanceCustomMessageTextReadModel {
return &InstanceCustomMessageTextReadModel{
CustomMessageTextReadModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -25,29 +25,29 @@ func NewIAMCustomMessageTextWriteModel(messageTextType string, lang language.Tag
}
}
func (wm *IAMCustomMessageTextReadModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceCustomMessageTextReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.CustomTextSetEvent:
case *instance.CustomTextSetEvent:
wm.CustomMessageTextReadModel.AppendEvents(&e.CustomTextSetEvent)
case *iam.CustomTextRemovedEvent:
case *instance.CustomTextRemovedEvent:
wm.CustomMessageTextReadModel.AppendEvents(&e.CustomTextRemovedEvent)
case *iam.CustomTextTemplateRemovedEvent:
case *instance.CustomTextTemplateRemovedEvent:
wm.CustomMessageTextReadModel.AppendEvents(&e.CustomTextTemplateRemovedEvent)
}
}
}
func (wm *IAMCustomMessageTextReadModel) Reduce() error {
func (wm *InstanceCustomMessageTextReadModel) Reduce() error {
return wm.CustomMessageTextReadModel.Reduce()
}
func (wm *IAMCustomMessageTextReadModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceCustomMessageTextReadModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.CustomMessageTextReadModel.AggregateID).
EventTypes(iam.CustomTextSetEventType, iam.CustomTextRemovedEventType, iam.CustomTextTemplateRemovedEventType).
EventTypes(instance.CustomTextSetEventType, instance.CustomTextRemovedEventType, instance.CustomTextTemplateRemovedEventType).
Builder()
}
@@ -11,7 +11,7 @@ import (
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
func TestCommandSide_SetDefaultMessageText(t *testing.T) {
@@ -56,8 +56,8 @@ func TestCommandSide_SetDefaultMessageText(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewCustomTextSetEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewCustomTextSetEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"Template",
domain.MessageGreeting,
"Greeting",
@@ -65,8 +65,8 @@ func TestCommandSide_SetDefaultMessageText(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewCustomTextSetEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewCustomTextSetEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"Template",
domain.MessageSubject,
"Subject",
@@ -74,8 +74,8 @@ func TestCommandSide_SetDefaultMessageText(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewCustomTextSetEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewCustomTextSetEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"Template",
domain.MessageTitle,
"Title",
@@ -83,8 +83,8 @@ func TestCommandSide_SetDefaultMessageText(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewCustomTextSetEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewCustomTextSetEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"Template",
domain.MessagePreHeader,
"PreHeader",
@@ -92,8 +92,8 @@ func TestCommandSide_SetDefaultMessageText(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewCustomTextSetEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewCustomTextSetEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"Template",
domain.MessageText,
"Text",
@@ -101,8 +101,8 @@ func TestCommandSide_SetDefaultMessageText(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewCustomTextSetEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewCustomTextSetEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"Template",
domain.MessageButtonText,
"ButtonText",
@@ -110,8 +110,8 @@ func TestCommandSide_SetDefaultMessageText(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewCustomTextSetEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewCustomTextSetEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"Template",
domain.MessageFooterText,
"Footer",
@@ -8,14 +8,14 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) SetIAMCustomText(ctx context.Context, customText *domain.CustomText) (*domain.CustomText, error) {
setText := NewIAMCustomTextWriteModel(customText.Key, customText.Language)
iamAgg := IAMAggregateFromWriteModel(&setText.CustomTextWriteModel.WriteModel)
event, err := c.setDefaultCustomText(ctx, iamAgg, setText, customText)
func (c *Commands) SetInstanceCustomText(ctx context.Context, customText *domain.CustomText) (*domain.CustomText, error) {
setText := NewInstanceCustomTextWriteModel(customText.Key, customText.Language)
instanceAgg := InstanceAggregateFromWriteModel(&setText.CustomTextWriteModel.WriteModel)
event, err := c.setDefaultCustomText(ctx, instanceAgg, setText, customText)
if err != nil {
return nil, err
}
@@ -31,28 +31,28 @@ func (c *Commands) SetIAMCustomText(ctx context.Context, customText *domain.Cust
return writeModelToCustomText(&setText.CustomTextWriteModel), nil
}
func (c *Commands) setDefaultCustomText(ctx context.Context, iamAgg *eventstore.Aggregate, addedPolicy *IAMCustomTextWriteModel, text *domain.CustomText) (eventstore.Command, error) {
func (c *Commands) setDefaultCustomText(ctx context.Context, instanceAgg *eventstore.Aggregate, addedPolicy *InstanceCustomTextWriteModel, text *domain.CustomText) (eventstore.Command, error) {
if !text.IsValid() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-3MN0s", "Errors.CustomText.Invalid")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-3MN0s", "Errors.CustomText.Invalid")
}
err := c.eventstore.FilterToQueryReducer(ctx, addedPolicy)
if err != nil {
return nil, err
}
return iam_repo.NewCustomTextSetEvent(
return instance.NewCustomTextSetEvent(
ctx,
iamAgg,
instanceAgg,
text.Template,
text.Key,
text.Text,
text.Language), nil
}
func (c *Commands) defaultCustomTextWriteModelByID(ctx context.Context, key string, language language.Tag) (policy *IAMCustomTextWriteModel, err error) {
func (c *Commands) defaultCustomTextWriteModelByID(ctx context.Context, key string, language language.Tag) (policy *InstanceCustomTextWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMCustomTextWriteModel(key, language)
writeModel := NewInstanceCustomTextWriteModel(key, language)
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -5,15 +5,15 @@ import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMCustomTextWriteModel struct {
type InstanceCustomTextWriteModel struct {
CustomTextWriteModel
}
func NewIAMCustomTextWriteModel(key string, language language.Tag) *IAMCustomTextWriteModel {
return &IAMCustomTextWriteModel{
func NewInstanceCustomTextWriteModel(key string, language language.Tag) *InstanceCustomTextWriteModel {
return &InstanceCustomTextWriteModel{
CustomTextWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -25,26 +25,26 @@ func NewIAMCustomTextWriteModel(key string, language language.Tag) *IAMCustomTex
}
}
func (wm *IAMCustomTextWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceCustomTextWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.CustomTextSetEvent:
case *instance.CustomTextSetEvent:
wm.CustomTextWriteModel.AppendEvents(&e.CustomTextSetEvent)
}
}
}
func (wm *IAMCustomTextWriteModel) Reduce() error {
func (wm *InstanceCustomTextWriteModel) Reduce() error {
return wm.CustomTextWriteModel.Reduce()
}
func (wm *IAMCustomTextWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceCustomTextWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateIDs(wm.CustomTextWriteModel.AggregateID).
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
EventTypes(
iam.CustomTextSetEventType).
instance.CustomTextSetEventType).
Builder()
}
@@ -7,14 +7,14 @@ import (
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/notification/channels/fs"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
iam_repo "github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddDebugNotificationProviderFile(ctx context.Context, fileSystemProvider *fs.FSConfig) (*domain.ObjectDetails, error) {
writeModel := NewIAMDebugNotificationFileWriteModel()
iamAgg := IAMAggregateFromWriteModel(&writeModel.WriteModel)
events, err := c.addDefaultDebugNotificationFile(ctx, iamAgg, writeModel, fileSystemProvider)
writeModel := NewInstanceDebugNotificationFileWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&writeModel.WriteModel)
events, err := c.addDefaultDebugNotificationFile(ctx, instanceAgg, writeModel, fileSystemProvider)
if err != nil {
return nil, err
}
@@ -29,27 +29,27 @@ func (c *Commands) AddDebugNotificationProviderFile(ctx context.Context, fileSys
return writeModelToObjectDetails(&writeModel.DebugNotificationWriteModel.WriteModel), nil
}
func (c *Commands) addDefaultDebugNotificationFile(ctx context.Context, iamAgg *eventstore.Aggregate, addedWriteModel *IAMDebugNotificationFileWriteModel, fileSystemProvider *fs.FSConfig) ([]eventstore.Command, error) {
func (c *Commands) addDefaultDebugNotificationFile(ctx context.Context, instanceAgg *eventstore.Aggregate, addedWriteModel *InstanceDebugNotificationFileWriteModel, fileSystemProvider *fs.FSConfig) ([]eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, addedWriteModel)
if err != nil {
return nil, err
}
if addedWriteModel.State.Exists() {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-d93nfs", "Errors.IAM.DebugNotificationProvider.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-d93nfs", "Errors.IAM.DebugNotificationProvider.AlreadyExists")
}
events := []eventstore.Command{
iam_repo.NewDebugNotificationProviderFileAddedEvent(ctx,
iamAgg,
instanceAgg,
fileSystemProvider.Compact),
}
return events, nil
}
func (c *Commands) ChangeDefaultNotificationFile(ctx context.Context, fileSystemProvider *fs.FSConfig) (*domain.ObjectDetails, error) {
writeModel := NewIAMDebugNotificationFileWriteModel()
iamAgg := IAMAggregateFromWriteModel(&writeModel.WriteModel)
events, err := c.changeDefaultDebugNotificationProviderFile(ctx, iamAgg, writeModel, fileSystemProvider)
writeModel := NewInstanceDebugNotificationFileWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&writeModel.WriteModel)
events, err := c.changeDefaultDebugNotificationProviderFile(ctx, instanceAgg, writeModel, fileSystemProvider)
if err != nil {
return nil, err
}
@@ -64,40 +64,40 @@ func (c *Commands) ChangeDefaultNotificationFile(ctx context.Context, fileSystem
return writeModelToObjectDetails(&writeModel.DebugNotificationWriteModel.WriteModel), nil
}
func (c *Commands) changeDefaultDebugNotificationProviderFile(ctx context.Context, iamAgg *eventstore.Aggregate, existingProvider *IAMDebugNotificationFileWriteModel, fileSystemProvider *fs.FSConfig) ([]eventstore.Command, error) {
func (c *Commands) changeDefaultDebugNotificationProviderFile(ctx context.Context, instanceAgg *eventstore.Aggregate, existingProvider *InstanceDebugNotificationFileWriteModel, fileSystemProvider *fs.FSConfig) ([]eventstore.Command, error) {
err := c.defaultDebugNotificationProviderFileWriteModelByID(ctx, existingProvider)
if err != nil {
return nil, err
}
if !existingProvider.State.Exists() {
return nil, caos_errs.ThrowNotFound(nil, "IAM-fm9wl", "Errors.IAM.DebugNotificationProvider.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-fm9wl", "Errors.IAM.DebugNotificationProvider.NotFound")
}
events := make([]eventstore.Command, 0)
changedEvent, hasChanged := existingProvider.NewChangedEvent(ctx,
iamAgg,
instanceAgg,
fileSystemProvider.Compact)
if hasChanged {
events = append(events, changedEvent)
}
if len(events) == 0 {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-5M9vdd", "Errors.IAM.LoginPolicy.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-5M9vdd", "Errors.IAM.LoginPolicy.NotChanged")
}
return events, nil
}
func (c *Commands) RemoveDefaultNotificationFile(ctx context.Context) (*domain.ObjectDetails, error) {
existingProvider := NewIAMDebugNotificationFileWriteModel()
iamAgg := IAMAggregateFromWriteModel(&existingProvider.WriteModel)
existingProvider := NewInstanceDebugNotificationFileWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&existingProvider.WriteModel)
err := c.defaultDebugNotificationProviderFileWriteModelByID(ctx, existingProvider)
if err != nil {
return nil, err
}
if !existingProvider.State.Exists() {
return nil, caos_errs.ThrowNotFound(nil, "IAM-dj9ew", "Errors.IAM.DebugNotificationProvider.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-dj9ew", "Errors.IAM.DebugNotificationProvider.NotFound")
}
events, err := c.eventstore.Push(ctx, iam_repo.NewDebugNotificationProviderFileRemovedEvent(ctx, iamAgg))
events, err := c.eventstore.Push(ctx, iam_repo.NewDebugNotificationProviderFileRemovedEvent(ctx, instanceAgg))
if err != nil {
return nil, err
}
@@ -108,7 +108,7 @@ func (c *Commands) RemoveDefaultNotificationFile(ctx context.Context) (*domain.O
return writeModelToObjectDetails(&existingProvider.DebugNotificationWriteModel.WriteModel), nil
}
func (c *Commands) defaultDebugNotificationProviderFileWriteModelByID(ctx context.Context, writeModel *IAMDebugNotificationFileWriteModel) (err error) {
func (c *Commands) defaultDebugNotificationProviderFileWriteModelByID(ctx context.Context, writeModel *InstanceDebugNotificationFileWriteModel) (err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
@@ -7,15 +7,15 @@ import (
"github.com/caos/zitadel/internal/repository/settings"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMDebugNotificationLogWriteModel struct {
type InstanceDebugNotificationFileWriteModel struct {
DebugNotificationWriteModel
}
func NewIAMDebugNotificationLogWriteModel() *IAMDebugNotificationLogWriteModel {
return &IAMDebugNotificationLogWriteModel{
func NewInstanceDebugNotificationFileWriteModel() *InstanceDebugNotificationFileWriteModel {
return &InstanceDebugNotificationFileWriteModel{
DebugNotificationWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -25,46 +25,44 @@ func NewIAMDebugNotificationLogWriteModel() *IAMDebugNotificationLogWriteModel {
}
}
func (wm *IAMDebugNotificationLogWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceDebugNotificationFileWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.DebugNotificationProviderLogAddedEvent:
case *instance.DebugNotificationProviderFileAddedEvent:
wm.DebugNotificationWriteModel.AppendEvents(&e.DebugNotificationProviderAddedEvent)
case *iam.DebugNotificationProviderLogChangedEvent:
case *instance.DebugNotificationProviderFileChangedEvent:
wm.DebugNotificationWriteModel.AppendEvents(&e.DebugNotificationProviderChangedEvent)
case *iam.DebugNotificationProviderLogRemovedEvent:
case *instance.DebugNotificationProviderFileRemovedEvent:
wm.DebugNotificationWriteModel.AppendEvents(&e.DebugNotificationProviderRemovedEvent)
}
}
}
func (wm *IAMDebugNotificationLogWriteModel) IsValid() bool {
func (wm *InstanceDebugNotificationFileWriteModel) IsValid() bool {
return wm.AggregateID != ""
}
func (wm *IAMDebugNotificationLogWriteModel) Reduce() error {
func (wm *InstanceDebugNotificationFileWriteModel) Reduce() error {
return wm.DebugNotificationWriteModel.Reduce()
}
func (wm *IAMDebugNotificationLogWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceDebugNotificationFileWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.DebugNotificationWriteModel.AggregateID).
EventTypes(
iam.DebugNotificationProviderLogAddedEventType,
iam.DebugNotificationProviderLogChangedEventType,
iam.DebugNotificationProviderLogEnabledEventType,
iam.DebugNotificationProviderLogDisabledEventType,
iam.DebugNotificationProviderLogRemovedEventType).
instance.DebugNotificationProviderFileAddedEventType,
instance.DebugNotificationProviderFileChangedEventType,
instance.DebugNotificationProviderFileRemovedEventType).
Builder()
}
func (wm *IAMDebugNotificationLogWriteModel) NewChangedEvent(
func (wm *InstanceDebugNotificationFileWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
compact bool) (*iam.DebugNotificationProviderLogChangedEvent, bool) {
compact bool) (*instance.DebugNotificationProviderFileChangedEvent, bool) {
changes := make([]settings.DebugNotificationProviderChanges, 0)
if wm.Compact != compact {
@@ -73,7 +71,7 @@ func (wm *IAMDebugNotificationLogWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewDebugNotificationProviderLogChangedEvent(ctx, aggregate, changes)
changedEvent, err := instance.NewDebugNotificationProviderFileChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
@@ -9,7 +9,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/notification/channels/fs"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/settings"
"github.com/stretchr/testify/assert"
@@ -40,8 +40,8 @@ func TestCommandSide_AddDefaultDebugNotificationProviderFile(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -68,8 +68,8 @@ func TestCommandSide_AddDefaultDebugNotificationProviderFile(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -153,8 +153,8 @@ func TestCommandSide_ChangeDebugNotificationProviderFile(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -179,8 +179,8 @@ func TestCommandSide_ChangeDebugNotificationProviderFile(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -205,8 +205,8 @@ func TestCommandSide_ChangeDebugNotificationProviderFile(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -293,8 +293,8 @@ func TestCommandSide_RemoveDebugNotificationProviderFile(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderFileAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -302,8 +302,8 @@ func TestCommandSide_RemoveDebugNotificationProviderFile(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewDebugNotificationProviderFileRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate),
instance.NewDebugNotificationProviderFileRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate),
),
},
),
@@ -337,9 +337,9 @@ func TestCommandSide_RemoveDebugNotificationProviderFile(t *testing.T) {
})
}
}
func newDefaultDebugNotificationFileChangedEvent(ctx context.Context, compact bool) *iam.DebugNotificationProviderFileChangedEvent {
event, _ := iam.NewDebugNotificationProviderFileChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultDebugNotificationFileChangedEvent(ctx context.Context, compact bool) *instance.DebugNotificationProviderFileChangedEvent {
event, _ := instance.NewDebugNotificationProviderFileChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
[]settings.DebugNotificationProviderChanges{
settings.ChangeCompact(compact),
},
@@ -7,14 +7,14 @@ import (
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/notification/channels/fs"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddDebugNotificationProviderLog(ctx context.Context, fileSystemProvider *fs.FSConfig) (*domain.ObjectDetails, error) {
writeModel := NewIAMDebugNotificationLogWriteModel()
iamAgg := IAMAggregateFromWriteModel(&writeModel.WriteModel)
events, err := c.addDefaultDebugNotificationLog(ctx, iamAgg, writeModel, fileSystemProvider)
writeModel := NewInstanceDebugNotificationLogWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&writeModel.WriteModel)
events, err := c.addDefaultDebugNotificationLog(ctx, instanceAgg, writeModel, fileSystemProvider)
if err != nil {
return nil, err
}
@@ -29,27 +29,27 @@ func (c *Commands) AddDebugNotificationProviderLog(ctx context.Context, fileSyst
return writeModelToObjectDetails(&writeModel.DebugNotificationWriteModel.WriteModel), nil
}
func (c *Commands) addDefaultDebugNotificationLog(ctx context.Context, iamAgg *eventstore.Aggregate, addedWriteModel *IAMDebugNotificationLogWriteModel, fileSystemProvider *fs.FSConfig) ([]eventstore.Command, error) {
func (c *Commands) addDefaultDebugNotificationLog(ctx context.Context, instanceAgg *eventstore.Aggregate, addedWriteModel *InstanceDebugNotificationLogWriteModel, fileSystemProvider *fs.FSConfig) ([]eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, addedWriteModel)
if err != nil {
return nil, err
}
if addedWriteModel.State.Exists() {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-3h0fs", "Errors.IAM.DebugNotificationProvider.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-3h0fs", "Errors.IAM.DebugNotificationProvider.AlreadyExists")
}
events := []eventstore.Command{
iam_repo.NewDebugNotificationProviderLogAddedEvent(ctx,
iamAgg,
instance.NewDebugNotificationProviderLogAddedEvent(ctx,
instanceAgg,
fileSystemProvider.Compact),
}
return events, nil
}
func (c *Commands) ChangeDefaultNotificationLog(ctx context.Context, fileSystemProvider *fs.FSConfig) (*domain.ObjectDetails, error) {
writeModel := NewIAMDebugNotificationLogWriteModel()
iamAgg := IAMAggregateFromWriteModel(&writeModel.WriteModel)
event, err := c.changeDefaultDebugNotificationProviderLog(ctx, iamAgg, writeModel, fileSystemProvider)
writeModel := NewInstanceDebugNotificationLogWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&writeModel.WriteModel)
event, err := c.changeDefaultDebugNotificationProviderLog(ctx, instanceAgg, writeModel, fileSystemProvider)
if err != nil {
return nil, err
}
@@ -64,35 +64,35 @@ func (c *Commands) ChangeDefaultNotificationLog(ctx context.Context, fileSystemP
return writeModelToObjectDetails(&writeModel.DebugNotificationWriteModel.WriteModel), nil
}
func (c *Commands) changeDefaultDebugNotificationProviderLog(ctx context.Context, iamAgg *eventstore.Aggregate, existingProvider *IAMDebugNotificationLogWriteModel, fileSystemProvider *fs.FSConfig) (eventstore.Command, error) {
func (c *Commands) changeDefaultDebugNotificationProviderLog(ctx context.Context, instanceAgg *eventstore.Aggregate, existingProvider *InstanceDebugNotificationLogWriteModel, fileSystemProvider *fs.FSConfig) (eventstore.Command, error) {
err := c.defaultDebugNotificationProviderLogWriteModelByID(ctx, existingProvider)
if err != nil {
return nil, err
}
if !existingProvider.State.Exists() {
return nil, caos_errs.ThrowNotFound(nil, "IAM-2h0s3", "Errors.IAM.DebugNotificationProvider.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-2h0s3", "Errors.IAM.DebugNotificationProvider.NotFound")
}
changedEvent, hasChanged := existingProvider.NewChangedEvent(ctx,
iamAgg,
instanceAgg,
fileSystemProvider.Compact)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-fn9p3", "Errors.IAM.LoginPolicy.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-fn9p3", "Errors.IAM.LoginPolicy.NotChanged")
}
return changedEvent, nil
}
func (c *Commands) RemoveDefaultNotificationLog(ctx context.Context) (*domain.ObjectDetails, error) {
existingProvider := NewIAMDebugNotificationLogWriteModel()
iamAgg := IAMAggregateFromWriteModel(&existingProvider.WriteModel)
existingProvider := NewInstanceDebugNotificationLogWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&existingProvider.WriteModel)
err := c.defaultDebugNotificationProviderLogWriteModelByID(ctx, existingProvider)
if err != nil {
return nil, err
}
if !existingProvider.State.Exists() {
return nil, caos_errs.ThrowNotFound(nil, "IAM-39lse", "Errors.IAM.DebugNotificationProvider.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-39lse", "Errors.IAM.DebugNotificationProvider.NotFound")
}
events, err := c.eventstore.Push(ctx, iam_repo.NewDebugNotificationProviderLogRemovedEvent(ctx, iamAgg))
events, err := c.eventstore.Push(ctx, instance.NewDebugNotificationProviderLogRemovedEvent(ctx, instanceAgg))
if err != nil {
return nil, err
}
@@ -103,7 +103,7 @@ func (c *Commands) RemoveDefaultNotificationLog(ctx context.Context) (*domain.Ob
return writeModelToObjectDetails(&existingProvider.DebugNotificationWriteModel.WriteModel), nil
}
func (c *Commands) defaultDebugNotificationProviderLogWriteModelByID(ctx context.Context, writeModel *IAMDebugNotificationLogWriteModel) (err error) {
func (c *Commands) defaultDebugNotificationProviderLogWriteModelByID(ctx context.Context, writeModel *InstanceDebugNotificationLogWriteModel) (err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
@@ -7,15 +7,15 @@ import (
"github.com/caos/zitadel/internal/repository/settings"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMDebugNotificationFileWriteModel struct {
type InstanceDebugNotificationLogWriteModel struct {
DebugNotificationWriteModel
}
func NewIAMDebugNotificationFileWriteModel() *IAMDebugNotificationFileWriteModel {
return &IAMDebugNotificationFileWriteModel{
func NewInstanceDebugNotificationLogWriteModel() *InstanceDebugNotificationLogWriteModel {
return &InstanceDebugNotificationLogWriteModel{
DebugNotificationWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -25,44 +25,46 @@ func NewIAMDebugNotificationFileWriteModel() *IAMDebugNotificationFileWriteModel
}
}
func (wm *IAMDebugNotificationFileWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceDebugNotificationLogWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.DebugNotificationProviderFileAddedEvent:
case *instance.DebugNotificationProviderLogAddedEvent:
wm.DebugNotificationWriteModel.AppendEvents(&e.DebugNotificationProviderAddedEvent)
case *iam.DebugNotificationProviderFileChangedEvent:
case *instance.DebugNotificationProviderLogChangedEvent:
wm.DebugNotificationWriteModel.AppendEvents(&e.DebugNotificationProviderChangedEvent)
case *iam.DebugNotificationProviderFileRemovedEvent:
case *instance.DebugNotificationProviderLogRemovedEvent:
wm.DebugNotificationWriteModel.AppendEvents(&e.DebugNotificationProviderRemovedEvent)
}
}
}
func (wm *IAMDebugNotificationFileWriteModel) IsValid() bool {
func (wm *InstanceDebugNotificationLogWriteModel) IsValid() bool {
return wm.AggregateID != ""
}
func (wm *IAMDebugNotificationFileWriteModel) Reduce() error {
func (wm *InstanceDebugNotificationLogWriteModel) Reduce() error {
return wm.DebugNotificationWriteModel.Reduce()
}
func (wm *IAMDebugNotificationFileWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceDebugNotificationLogWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.DebugNotificationWriteModel.AggregateID).
EventTypes(
iam.DebugNotificationProviderFileAddedEventType,
iam.DebugNotificationProviderFileChangedEventType,
iam.DebugNotificationProviderFileRemovedEventType).
instance.DebugNotificationProviderLogAddedEventType,
instance.DebugNotificationProviderLogChangedEventType,
instance.DebugNotificationProviderLogEnabledEventType,
instance.DebugNotificationProviderLogDisabledEventType,
instance.DebugNotificationProviderLogRemovedEventType).
Builder()
}
func (wm *IAMDebugNotificationFileWriteModel) NewChangedEvent(
func (wm *InstanceDebugNotificationLogWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
compact bool) (*iam.DebugNotificationProviderFileChangedEvent, bool) {
compact bool) (*instance.DebugNotificationProviderLogChangedEvent, bool) {
changes := make([]settings.DebugNotificationProviderChanges, 0)
if wm.Compact != compact {
@@ -71,7 +73,7 @@ func (wm *IAMDebugNotificationFileWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewDebugNotificationProviderFileChangedEvent(ctx, aggregate, changes)
changedEvent, err := instance.NewDebugNotificationProviderLogChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
@@ -9,7 +9,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/notification/channels/fs"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/settings"
"github.com/stretchr/testify/assert"
@@ -40,8 +40,8 @@ func TestCommandSide_AddDefaultDebugNotificationProviderLog(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -68,8 +68,8 @@ func TestCommandSide_AddDefaultDebugNotificationProviderLog(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -98,8 +98,8 @@ func TestCommandSide_AddDefaultDebugNotificationProviderLog(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -184,8 +184,8 @@ func TestCommandSide_ChangeDebugNotificationProviderLog(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -210,8 +210,8 @@ func TestCommandSide_ChangeDebugNotificationProviderLog(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -246,8 +246,8 @@ func TestCommandSide_ChangeDebugNotificationProviderLog(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -334,8 +334,8 @@ func TestCommandSide_RemoveDebugNotificationProviderLog(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewDebugNotificationProviderLogAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -343,8 +343,8 @@ func TestCommandSide_RemoveDebugNotificationProviderLog(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewDebugNotificationProviderLogRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate),
instance.NewDebugNotificationProviderLogRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate),
),
},
),
@@ -378,9 +378,9 @@ func TestCommandSide_RemoveDebugNotificationProviderLog(t *testing.T) {
})
}
}
func newDefaultDebugNotificationLogChangedEvent(ctx context.Context, compact bool) *iam.DebugNotificationProviderLogChangedEvent {
event, _ := iam.NewDebugNotificationProviderLogChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultDebugNotificationLogChangedEvent(ctx context.Context, compact bool) *instance.DebugNotificationProviderLogChangedEvent {
event, _ := instance.NewDebugNotificationProviderLogChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
[]settings.DebugNotificationProviderChanges{
settings.ChangeCompact(compact),
},
@@ -4,13 +4,13 @@ import (
"context"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/domain"
)
func (c *Commands) SetDefaultFeatures(ctx context.Context, features *domain.Features) (*domain.ObjectDetails, error) {
existingFeatures := NewIAMFeaturesWriteModel()
existingFeatures := NewInstanceFeaturesWriteModel()
setEvent, err := c.setDefaultFeatures(ctx, existingFeatures, features)
if err != nil {
return nil, err
@@ -27,14 +27,14 @@ func (c *Commands) SetDefaultFeatures(ctx context.Context, features *domain.Feat
return writeModelToObjectDetails(&existingFeatures.WriteModel), nil
}
func (c *Commands) setDefaultFeatures(ctx context.Context, existingFeatures *IAMFeaturesWriteModel, features *domain.Features) (*iam.FeaturesSetEvent, error) {
func (c *Commands) setDefaultFeatures(ctx context.Context, existingFeatures *InstanceFeaturesWriteModel, features *domain.Features) (*instance.FeaturesSetEvent, error) {
err := c.eventstore.FilterToQueryReducer(ctx, existingFeatures)
if err != nil {
return nil, err
}
setEvent, hasChanged := existingFeatures.NewSetEvent(
ctx,
IAMAggregateFromWriteModel(&existingFeatures.FeaturesWriteModel.WriteModel),
InstanceAggregateFromWriteModel(&existingFeatures.FeaturesWriteModel.WriteModel),
features.TierName,
features.TierDescription,
features.State,
@@ -65,7 +65,7 @@ func (c *Commands) setDefaultFeatures(ctx context.Context, existingFeatures *IAM
}
func (c *Commands) getDefaultFeatures(ctx context.Context) (*domain.Features, error) {
existingFeatures := NewIAMFeaturesWriteModel()
existingFeatures := NewInstanceFeaturesWriteModel()
err := c.eventstore.FilterToQueryReducer(ctx, existingFeatures)
if err != nil {
return nil, err
@@ -7,15 +7,15 @@ import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/features"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMFeaturesWriteModel struct {
type InstanceFeaturesWriteModel struct {
FeaturesWriteModel
}
func NewIAMFeaturesWriteModel() *IAMFeaturesWriteModel {
return &IAMFeaturesWriteModel{
func NewInstanceFeaturesWriteModel() *InstanceFeaturesWriteModel {
return &InstanceFeaturesWriteModel{
FeaturesWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -25,33 +25,33 @@ func NewIAMFeaturesWriteModel() *IAMFeaturesWriteModel {
}
}
func (wm *IAMFeaturesWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceFeaturesWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.FeaturesSetEvent:
case *instance.FeaturesSetEvent:
wm.FeaturesWriteModel.AppendEvents(&e.FeaturesSetEvent)
}
}
}
func (wm *IAMFeaturesWriteModel) IsValid() bool {
func (wm *InstanceFeaturesWriteModel) IsValid() bool {
return wm.AggregateID != ""
}
func (wm *IAMFeaturesWriteModel) Reduce() error {
func (wm *InstanceFeaturesWriteModel) Reduce() error {
return wm.FeaturesWriteModel.Reduce()
}
func (wm *IAMFeaturesWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceFeaturesWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
EventTypes(iam.FeaturesSetEventType).
AggregateTypes(iam.AggregateType).
EventTypes(instance.FeaturesSetEventType).
AggregateTypes(instance.AggregateType).
Builder()
}
func (wm *IAMFeaturesWriteModel) NewSetEvent(
func (wm *InstanceFeaturesWriteModel) NewSetEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
tierName, tierDescription string,
@@ -75,7 +75,7 @@ func (wm *IAMFeaturesWriteModel) NewSetEvent(
lockoutPolicy bool,
actionsAllowed domain.ActionsAllowed,
maxActions int,
) (*iam.FeaturesSetEvent, bool) {
) (*instance.FeaturesSetEvent, bool) {
changes := make([]features.FeaturesChanges, 0)
@@ -148,7 +148,7 @@ func (wm *IAMFeaturesWriteModel) NewSetEvent(
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewFeaturesSetEvent(ctx, aggregate, changes)
changedEvent, err := instance.NewFeaturesSetEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
@@ -10,7 +10,7 @@ import (
"github.com/caos/zitadel/internal/crypto"
"github.com/caos/zitadel/internal/errors"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
func (c *Commands) AddDefaultIDPConfig(ctx context.Context, config *domain.IDPConfig) (*domain.IDPConfig, error) {
@@ -21,13 +21,13 @@ func (c *Commands) AddDefaultIDPConfig(ctx context.Context, config *domain.IDPCo
if err != nil {
return nil, err
}
addedConfig := NewIAMIDPConfigWriteModel(idpConfigID)
addedConfig := NewInstanceIDPConfigWriteModel(idpConfigID)
iamAgg := IAMAggregateFromWriteModel(&addedConfig.WriteModel)
instanceAgg := InstanceAggregateFromWriteModel(&addedConfig.WriteModel)
events := []eventstore.Command{
iam_repo.NewIDPConfigAddedEvent(
instance.NewIDPConfigAddedEvent(
ctx,
iamAgg,
instanceAgg,
idpConfigID,
config.Name,
config.Type,
@@ -41,9 +41,9 @@ func (c *Commands) AddDefaultIDPConfig(ctx context.Context, config *domain.IDPCo
return nil, err
}
events = append(events, iam_repo.NewIDPOIDCConfigAddedEvent(
events = append(events, instance.NewIDPOIDCConfigAddedEvent(
ctx,
iamAgg,
instanceAgg,
config.OIDCConfig.ClientID,
idpConfigID,
config.OIDCConfig.Issuer,
@@ -55,9 +55,9 @@ func (c *Commands) AddDefaultIDPConfig(ctx context.Context, config *domain.IDPCo
config.OIDCConfig.Scopes...,
))
} else if config.JWTConfig != nil {
events = append(events, iam_repo.NewIDPJWTConfigAddedEvent(
events = append(events, instance.NewIDPJWTConfigAddedEvent(
ctx,
iamAgg,
instanceAgg,
idpConfigID,
config.JWTConfig.JWTEndpoint,
config.JWTConfig.Issuer,
@@ -78,20 +78,20 @@ func (c *Commands) AddDefaultIDPConfig(ctx context.Context, config *domain.IDPCo
func (c *Commands) ChangeDefaultIDPConfig(ctx context.Context, config *domain.IDPConfig) (*domain.IDPConfig, error) {
if config.IDPConfigID == "" {
return nil, errors.ThrowInvalidArgument(nil, "IAM-4m9gs", "Errors.IDMissing")
return nil, errors.ThrowInvalidArgument(nil, "INSTANCE-4m9gs", "Errors.IDMissing")
}
existingIDP, err := c.iamIDPConfigWriteModelByID(ctx, config.IDPConfigID)
existingIDP, err := c.isntanceIDPConfigWriteModelByID(ctx, config.IDPConfigID)
if err != nil {
return nil, err
}
if existingIDP.State == domain.IDPConfigStateRemoved || existingIDP.State == domain.IDPConfigStateUnspecified {
return nil, caos_errs.ThrowNotFound(nil, "IAM-m0e3r", "Errors.IDPConfig.NotExisting")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-m0e3r", "Errors.IDPConfig.NotExisting")
}
iamAgg := IAMAggregateFromWriteModel(&existingIDP.WriteModel)
changedEvent, hasChanged := existingIDP.NewChangedEvent(ctx, iamAgg, config.IDPConfigID, config.Name, config.StylingType, config.AutoRegister)
instanceAgg := InstanceAggregateFromWriteModel(&existingIDP.WriteModel)
changedEvent, hasChanged := existingIDP.NewChangedEvent(ctx, instanceAgg, config.IDPConfigID, config.Name, config.StylingType, config.AutoRegister)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
}
pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
if err != nil {
@@ -105,15 +105,15 @@ func (c *Commands) ChangeDefaultIDPConfig(ctx context.Context, config *domain.ID
}
func (c *Commands) DeactivateDefaultIDPConfig(ctx context.Context, idpID string) (*domain.ObjectDetails, error) {
existingIDP, err := c.iamIDPConfigWriteModelByID(ctx, idpID)
existingIDP, err := c.isntanceIDPConfigWriteModelByID(ctx, idpID)
if err != nil {
return nil, err
}
if existingIDP.State != domain.IDPConfigStateActive {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-2n0fs", "Errors.IAM.IDPConfig.NotActive")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-2n0fs", "Errors.IAM.IDPConfig.NotActive")
}
iamAgg := IAMAggregateFromWriteModel(&existingIDP.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewIDPConfigDeactivatedEvent(ctx, iamAgg, idpID))
instanceAgg := InstanceAggregateFromWriteModel(&existingIDP.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewIDPConfigDeactivatedEvent(ctx, instanceAgg, idpID))
if err != nil {
return nil, err
}
@@ -125,15 +125,15 @@ func (c *Commands) DeactivateDefaultIDPConfig(ctx context.Context, idpID string)
}
func (c *Commands) ReactivateDefaultIDPConfig(ctx context.Context, idpID string) (*domain.ObjectDetails, error) {
existingIDP, err := c.iamIDPConfigWriteModelByID(ctx, idpID)
existingIDP, err := c.isntanceIDPConfigWriteModelByID(ctx, idpID)
if err != nil {
return nil, err
}
if existingIDP.State != domain.IDPConfigStateInactive {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-5Mo0d", "Errors.IAM.IDPConfig.NotInactive")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-5Mo0d", "Errors.IAM.IDPConfig.NotInactive")
}
iamAgg := IAMAggregateFromWriteModel(&existingIDP.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewIDPConfigReactivatedEvent(ctx, iamAgg, idpID))
instanceAgg := InstanceAggregateFromWriteModel(&existingIDP.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewIDPConfigReactivatedEvent(ctx, instanceAgg, idpID))
if err != nil {
return nil, err
}
@@ -145,22 +145,22 @@ func (c *Commands) ReactivateDefaultIDPConfig(ctx context.Context, idpID string)
}
func (c *Commands) RemoveDefaultIDPConfig(ctx context.Context, idpID string, idpProviders []*domain.IDPProvider, externalIDPs ...*domain.UserIDPLink) (*domain.ObjectDetails, error) {
existingIDP, err := c.iamIDPConfigWriteModelByID(ctx, idpID)
existingIDP, err := c.isntanceIDPConfigWriteModelByID(ctx, idpID)
if err != nil {
return nil, err
}
if existingIDP.State == domain.IDPConfigStateRemoved || existingIDP.State == domain.IDPConfigStateUnspecified {
return nil, caos_errs.ThrowNotFound(nil, "IAM-4M0xy", "Errors.IDPConfig.NotExisting")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-4M0xy", "Errors.IDPConfig.NotExisting")
}
iamAgg := IAMAggregateFromWriteModel(&existingIDP.WriteModel)
instanceAgg := InstanceAggregateFromWriteModel(&existingIDP.WriteModel)
events := []eventstore.Command{
iam_repo.NewIDPConfigRemovedEvent(ctx, iamAgg, idpID, existingIDP.Name),
instance.NewIDPConfigRemovedEvent(ctx, instanceAgg, idpID, existingIDP.Name),
}
for _, idpProvider := range idpProviders {
if idpProvider.AggregateID == domain.IAMID {
userEvents := c.removeIDPProviderFromDefaultLoginPolicy(ctx, iamAgg, idpProvider, true, externalIDPs...)
userEvents := c.removeIDPProviderFromDefaultLoginPolicy(ctx, instanceAgg, idpProvider, true, externalIDPs...)
events = append(events, userEvents...)
}
orgAgg := OrgAggregateFromWriteModel(&NewOrgIdentityProviderWriteModel(idpProvider.AggregateID, idpID).WriteModel)
@@ -179,22 +179,22 @@ func (c *Commands) RemoveDefaultIDPConfig(ctx context.Context, idpID string, idp
return writeModelToObjectDetails(&existingIDP.IDPConfigWriteModel.WriteModel), nil
}
func (c *Commands) getIAMIDPConfigByID(ctx context.Context, idpID string) (*domain.IDPConfig, error) {
config, err := c.iamIDPConfigWriteModelByID(ctx, idpID)
func (c *Commands) getInstanceIDPConfigByID(ctx context.Context, idpID string) (*domain.IDPConfig, error) {
config, err := c.isntanceIDPConfigWriteModelByID(ctx, idpID)
if err != nil {
return nil, err
}
if !config.State.Exists() {
return nil, caos_errs.ThrowNotFound(nil, "IAM-p0pFF", "Errors.IDPConfig.NotExisting")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-p0pFF", "Errors.IDPConfig.NotExisting")
}
return writeModelToIDPConfig(&config.IDPConfigWriteModel), nil
}
func (c *Commands) iamIDPConfigWriteModelByID(ctx context.Context, idpID string) (policy *IAMIDPConfigWriteModel, err error) {
func (c *Commands) isntanceIDPConfigWriteModelByID(ctx context.Context, idpID string) (policy *InstanceIDPConfigWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMIDPConfigWriteModel(idpID)
writeModel := NewInstanceIDPConfigWriteModel(idpID)
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -6,16 +6,16 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/idpconfig"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMIDPConfigWriteModel struct {
type InstanceIDPConfigWriteModel struct {
IDPConfigWriteModel
}
func NewIAMIDPConfigWriteModel(configID string) *IAMIDPConfigWriteModel {
return &IAMIDPConfigWriteModel{
func NewInstanceIDPConfigWriteModel(configID string) *InstanceIDPConfigWriteModel {
return &InstanceIDPConfigWriteModel{
IDPConfigWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -26,57 +26,57 @@ func NewIAMIDPConfigWriteModel(configID string) *IAMIDPConfigWriteModel {
}
}
func (wm *IAMIDPConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceIDPConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.AggregateID).
EventTypes(
iam.IDPConfigAddedEventType,
iam.IDPConfigChangedEventType,
iam.IDPConfigDeactivatedEventType,
iam.IDPConfigReactivatedEventType,
iam.IDPConfigRemovedEventType,
iam.IDPOIDCConfigAddedEventType,
iam.IDPOIDCConfigChangedEventType).
instance.IDPConfigAddedEventType,
instance.IDPConfigChangedEventType,
instance.IDPConfigDeactivatedEventType,
instance.IDPConfigReactivatedEventType,
instance.IDPConfigRemovedEventType,
instance.IDPOIDCConfigAddedEventType,
instance.IDPOIDCConfigChangedEventType).
Builder()
}
func (wm *IAMIDPConfigWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceIDPConfigWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.IDPConfigAddedEvent:
case *instance.IDPConfigAddedEvent:
if wm.ConfigID != e.ConfigID {
continue
}
wm.IDPConfigWriteModel.AppendEvents(&e.IDPConfigAddedEvent)
case *iam.IDPConfigChangedEvent:
case *instance.IDPConfigChangedEvent:
if wm.ConfigID != e.ConfigID {
continue
}
wm.IDPConfigWriteModel.AppendEvents(&e.IDPConfigChangedEvent)
case *iam.IDPConfigDeactivatedEvent:
case *instance.IDPConfigDeactivatedEvent:
if wm.ConfigID != e.ConfigID {
continue
}
wm.IDPConfigWriteModel.AppendEvents(&e.IDPConfigDeactivatedEvent)
case *iam.IDPConfigReactivatedEvent:
case *instance.IDPConfigReactivatedEvent:
if wm.ConfigID != e.ConfigID {
continue
}
wm.IDPConfigWriteModel.AppendEvents(&e.IDPConfigReactivatedEvent)
case *iam.IDPConfigRemovedEvent:
case *instance.IDPConfigRemovedEvent:
if wm.ConfigID != e.ConfigID {
continue
}
wm.IDPConfigWriteModel.AppendEvents(&e.IDPConfigRemovedEvent)
case *iam.IDPOIDCConfigAddedEvent:
case *instance.IDPOIDCConfigAddedEvent:
if wm.ConfigID != e.IDPConfigID {
continue
}
wm.IDPConfigWriteModel.AppendEvents(&e.OIDCConfigAddedEvent)
case *iam.IDPOIDCConfigChangedEvent:
case *instance.IDPOIDCConfigChangedEvent:
if wm.ConfigID != e.IDPConfigID {
continue
}
@@ -85,23 +85,23 @@ func (wm *IAMIDPConfigWriteModel) AppendEvents(events ...eventstore.Event) {
}
}
func (wm *IAMIDPConfigWriteModel) Reduce() error {
func (wm *InstanceIDPConfigWriteModel) Reduce() error {
return wm.IDPConfigWriteModel.Reduce()
}
func (wm *IAMIDPConfigWriteModel) AppendAndReduce(events ...eventstore.Event) error {
func (wm *InstanceIDPConfigWriteModel) AppendAndReduce(events ...eventstore.Event) error {
wm.AppendEvents(events...)
return wm.Reduce()
}
func (wm *IAMIDPConfigWriteModel) NewChangedEvent(
func (wm *InstanceIDPConfigWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
configID,
name string,
stylingType domain.IDPConfigStylingType,
autoRegister bool,
) (*iam.IDPConfigChangedEvent, bool) {
) (*instance.IDPConfigChangedEvent, bool) {
changes := make([]idpconfig.IDPConfigChanges, 0)
oldName := ""
@@ -118,7 +118,7 @@ func (wm *IAMIDPConfigWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false
}
changeEvent, err := iam.NewIDPConfigChangedEvent(ctx, aggregate, configID, oldName, changes)
changeEvent, err := instance.NewIDPConfigChangedEvent(ctx, aggregate, configID, oldName, changes)
if err != nil {
return nil, false
}
@@ -15,8 +15,8 @@ import (
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/id"
id_mock "github.com/caos/zitadel/internal/id/mock"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/idpconfig"
"github.com/caos/zitadel/internal/repository/instance"
)
func TestCommandSide_AddDefaultIDPConfig(t *testing.T) {
@@ -62,8 +62,8 @@ func TestCommandSide_AddDefaultIDPConfig(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name1",
domain.IDPConfigTypeOIDC,
@@ -72,8 +72,8 @@ func TestCommandSide_AddDefaultIDPConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPOIDCConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPOIDCConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"clientid1",
"config1",
"issuer",
@@ -137,8 +137,8 @@ func TestCommandSide_AddDefaultIDPConfig(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name1",
domain.IDPConfigTypeOIDC,
@@ -147,8 +147,8 @@ func TestCommandSide_AddDefaultIDPConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPJWTConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPJWTConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"jwt-endpoint",
"issuer",
@@ -268,8 +268,8 @@ func TestCommandSide_ChangeDefaultIDPConfig(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name1",
domain.IDPConfigTypeOIDC,
@@ -278,8 +278,8 @@ func TestCommandSide_ChangeDefaultIDPConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPOIDCConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPOIDCConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"clientid1",
"config1",
"issuer",
@@ -351,9 +351,9 @@ func TestCommandSide_ChangeDefaultIDPConfig(t *testing.T) {
}
}
func newDefaultIDPConfigChangedEvent(ctx context.Context, configID, oldName, newName string, stylingType domain.IDPConfigStylingType, autoRegister bool) *iam.IDPConfigChangedEvent {
event, _ := iam.NewIDPConfigChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultIDPConfigChangedEvent(ctx context.Context, configID, oldName, newName string, stylingType domain.IDPConfigStylingType, autoRegister bool) *instance.IDPConfigChangedEvent {
event, _ := instance.NewIDPConfigChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
configID,
oldName,
[]idpconfig.IDPConfigChanges{
@@ -9,22 +9,22 @@ import (
func (c *Commands) ChangeDefaultIDPJWTConfig(ctx context.Context, config *domain.JWTIDPConfig) (*domain.JWTIDPConfig, error) {
if config.IDPConfigID == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-m9322", "Errors.IDMissing")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-m9322", "Errors.IDMissing")
}
existingConfig := NewIAMIDPJWTConfigWriteModel(config.IDPConfigID)
existingConfig := NewInstanceIDPJWTConfigWriteModel(config.IDPConfigID)
err := c.eventstore.FilterToQueryReducer(ctx, existingConfig)
if err != nil {
return nil, err
}
if existingConfig.State == domain.IDPConfigStateRemoved || existingConfig.State == domain.IDPConfigStateUnspecified {
return nil, caos_errs.ThrowNotFound(nil, "IAM-2m00d", "Errors.IAM.IDPConfig.AlreadyExists")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-2m00d", "Errors.IAM.IDPConfig.AlreadyExists")
}
iamAgg := IAMAggregateFromWriteModel(&existingConfig.WriteModel)
instanceAgg := InstanceAggregateFromWriteModel(&existingConfig.WriteModel)
changedEvent, hasChanged, err := existingConfig.NewChangedEvent(
ctx,
iamAgg,
instanceAgg,
config.IDPConfigID,
config.JWTEndpoint,
config.Issuer,
@@ -34,7 +34,7 @@ func (c *Commands) ChangeDefaultIDPJWTConfig(ctx context.Context, config *domain
return nil, err
}
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-3n9gg", "Errors.IAM.IDPConfig.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-3n9gg", "Errors.IAM.IDPConfig.NotChanged")
}
pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
@@ -6,16 +6,16 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/idpconfig"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMIDPJWTConfigWriteModel struct {
type InstanceIDPJWTConfigWriteModel struct {
JWTConfigWriteModel
}
func NewIAMIDPJWTConfigWriteModel(idpConfigID string) *IAMIDPJWTConfigWriteModel {
return &IAMIDPJWTConfigWriteModel{
func NewInstanceIDPJWTConfigWriteModel(idpConfigID string) *InstanceIDPJWTConfigWriteModel {
return &InstanceIDPJWTConfigWriteModel{
JWTConfigWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -26,30 +26,30 @@ func NewIAMIDPJWTConfigWriteModel(idpConfigID string) *IAMIDPJWTConfigWriteModel
}
}
func (wm *IAMIDPJWTConfigWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceIDPJWTConfigWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.IDPJWTConfigAddedEvent:
case *instance.IDPJWTConfigAddedEvent:
if wm.IDPConfigID != e.IDPConfigID {
continue
}
wm.JWTConfigWriteModel.AppendEvents(&e.JWTConfigAddedEvent)
case *iam.IDPJWTConfigChangedEvent:
case *instance.IDPJWTConfigChangedEvent:
if wm.IDPConfigID != e.IDPConfigID {
continue
}
wm.JWTConfigWriteModel.AppendEvents(&e.JWTConfigChangedEvent)
case *iam.IDPConfigReactivatedEvent:
case *instance.IDPConfigReactivatedEvent:
if wm.IDPConfigID != e.ConfigID {
continue
}
wm.JWTConfigWriteModel.AppendEvents(&e.IDPConfigReactivatedEvent)
case *iam.IDPConfigDeactivatedEvent:
case *instance.IDPConfigDeactivatedEvent:
if wm.IDPConfigID != e.ConfigID {
continue
}
wm.JWTConfigWriteModel.AppendEvents(&e.IDPConfigDeactivatedEvent)
case *iam.IDPConfigRemovedEvent:
case *instance.IDPConfigRemovedEvent:
if wm.IDPConfigID != e.ConfigID {
continue
}
@@ -60,29 +60,29 @@ func (wm *IAMIDPJWTConfigWriteModel) AppendEvents(events ...eventstore.Event) {
}
}
func (wm *IAMIDPJWTConfigWriteModel) Reduce() error {
func (wm *InstanceIDPJWTConfigWriteModel) Reduce() error {
if err := wm.JWTConfigWriteModel.Reduce(); err != nil {
return err
}
return wm.WriteModel.Reduce()
}
func (wm *IAMIDPJWTConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceIDPJWTConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.AggregateID).
EventTypes(
iam.IDPJWTConfigAddedEventType,
iam.IDPJWTConfigChangedEventType,
iam.IDPConfigReactivatedEventType,
iam.IDPConfigDeactivatedEventType,
iam.IDPConfigRemovedEventType).
instance.IDPJWTConfigAddedEventType,
instance.IDPJWTConfigChangedEventType,
instance.IDPConfigReactivatedEventType,
instance.IDPConfigDeactivatedEventType,
instance.IDPConfigRemovedEventType).
Builder()
}
func (wm *IAMIDPJWTConfigWriteModel) NewChangedEvent(
func (wm *InstanceIDPJWTConfigWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
idpConfigID,
@@ -90,7 +90,7 @@ func (wm *IAMIDPJWTConfigWriteModel) NewChangedEvent(
issuer,
keysEndpoint,
headerName string,
) (*iam.IDPJWTConfigChangedEvent, bool, error) {
) (*instance.IDPJWTConfigChangedEvent, bool, error) {
changes := make([]idpconfig.JWTConfigChanges, 0)
if wm.JWTEndpoint != jwtEndpoint {
@@ -108,7 +108,7 @@ func (wm *IAMIDPJWTConfigWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false, nil
}
changeEvent, err := iam.NewIDPJWTConfigChangedEvent(ctx, aggregate, idpConfigID, changes)
changeEvent, err := instance.NewIDPJWTConfigChangedEvent(ctx, aggregate, idpConfigID, changes)
if err != nil {
return nil, false, err
}
@@ -13,8 +13,8 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/idpconfig"
"github.com/caos/zitadel/internal/repository/instance"
)
func TestCommandSide_ChangeDefaultIDPJWTConfig(t *testing.T) {
@@ -78,8 +78,8 @@ func TestCommandSide_ChangeDefaultIDPJWTConfig(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name1",
domain.IDPConfigTypeJWT,
@@ -88,8 +88,8 @@ func TestCommandSide_ChangeDefaultIDPJWTConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPJWTConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPJWTConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"jwt-endpoint",
"issuer",
@@ -98,8 +98,8 @@ func TestCommandSide_ChangeDefaultIDPJWTConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPConfigRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name",
),
@@ -124,8 +124,8 @@ func TestCommandSide_ChangeDefaultIDPJWTConfig(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name1",
domain.IDPConfigTypeJWT,
@@ -134,8 +134,8 @@ func TestCommandSide_ChangeDefaultIDPJWTConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPJWTConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPJWTConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"jwt-endpoint",
"issuer",
@@ -168,8 +168,8 @@ func TestCommandSide_ChangeDefaultIDPJWTConfig(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name1",
domain.IDPConfigTypeJWT,
@@ -178,8 +178,8 @@ func TestCommandSide_ChangeDefaultIDPJWTConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPJWTConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPJWTConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"jwt-endpoint",
"issuer",
@@ -249,9 +249,9 @@ func TestCommandSide_ChangeDefaultIDPJWTConfig(t *testing.T) {
}
}
func newDefaultIDPJWTConfigChangedEvent(ctx context.Context, configID, jwtEndpoint, issuer, keysEndpoint, headerName string) *iam.IDPJWTConfigChangedEvent {
event, _ := iam.NewIDPJWTConfigChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultIDPJWTConfigChangedEvent(ctx context.Context, configID, jwtEndpoint, issuer, keysEndpoint, headerName string) *instance.IDPJWTConfigChangedEvent {
event, _ := instance.NewIDPJWTConfigChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
configID,
[]idpconfig.JWTConfigChanges{
idpconfig.ChangeJWTEndpoint(jwtEndpoint),
@@ -9,22 +9,22 @@ import (
func (c *Commands) ChangeDefaultIDPOIDCConfig(ctx context.Context, config *domain.OIDCIDPConfig) (*domain.OIDCIDPConfig, error) {
if config.IDPConfigID == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-9djf8", "Errors.IDMissing")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-9djf8", "Errors.IDMissing")
}
existingConfig := NewIAMIDPOIDCConfigWriteModel(config.IDPConfigID)
existingConfig := NewInstanceIDPOIDCConfigWriteModel(config.IDPConfigID)
err := c.eventstore.FilterToQueryReducer(ctx, existingConfig)
if err != nil {
return nil, err
}
if existingConfig.State == domain.IDPConfigStateRemoved || existingConfig.State == domain.IDPConfigStateUnspecified {
return nil, caos_errs.ThrowNotFound(nil, "IAM-67J9d", "Errors.IAM.IDPConfig.AlreadyExists")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-67J9d", "Errors.IAM.IDPConfig.AlreadyExists")
}
iamAgg := IAMAggregateFromWriteModel(&existingConfig.WriteModel)
instanceAgg := InstanceAggregateFromWriteModel(&existingConfig.WriteModel)
changedEvent, hasChanged, err := existingConfig.NewChangedEvent(
ctx,
iamAgg,
instanceAgg,
config.IDPConfigID,
config.ClientID,
config.Issuer,
@@ -39,7 +39,7 @@ func (c *Commands) ChangeDefaultIDPOIDCConfig(ctx context.Context, config *domai
return nil, err
}
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
}
pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
@@ -8,16 +8,16 @@ import (
"github.com/caos/zitadel/internal/crypto"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/idpconfig"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMIDPOIDCConfigWriteModel struct {
type InstanceIDPOIDCConfigWriteModel struct {
OIDCConfigWriteModel
}
func NewIAMIDPOIDCConfigWriteModel(idpConfigID string) *IAMIDPOIDCConfigWriteModel {
return &IAMIDPOIDCConfigWriteModel{
func NewInstanceIDPOIDCConfigWriteModel(idpConfigID string) *InstanceIDPOIDCConfigWriteModel {
return &InstanceIDPOIDCConfigWriteModel{
OIDCConfigWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -28,30 +28,30 @@ func NewIAMIDPOIDCConfigWriteModel(idpConfigID string) *IAMIDPOIDCConfigWriteMod
}
}
func (wm *IAMIDPOIDCConfigWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceIDPOIDCConfigWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.IDPOIDCConfigAddedEvent:
case *instance.IDPOIDCConfigAddedEvent:
if wm.IDPConfigID != e.IDPConfigID {
continue
}
wm.OIDCConfigWriteModel.AppendEvents(&e.OIDCConfigAddedEvent)
case *iam.IDPOIDCConfigChangedEvent:
case *instance.IDPOIDCConfigChangedEvent:
if wm.IDPConfigID != e.IDPConfigID {
continue
}
wm.OIDCConfigWriteModel.AppendEvents(&e.OIDCConfigChangedEvent)
case *iam.IDPConfigReactivatedEvent:
case *instance.IDPConfigReactivatedEvent:
if wm.IDPConfigID != e.ConfigID {
continue
}
wm.OIDCConfigWriteModel.AppendEvents(&e.IDPConfigReactivatedEvent)
case *iam.IDPConfigDeactivatedEvent:
case *instance.IDPConfigDeactivatedEvent:
if wm.IDPConfigID != e.ConfigID {
continue
}
wm.OIDCConfigWriteModel.AppendEvents(&e.IDPConfigDeactivatedEvent)
case *iam.IDPConfigRemovedEvent:
case *instance.IDPConfigRemovedEvent:
if wm.IDPConfigID != e.ConfigID {
continue
}
@@ -62,29 +62,29 @@ func (wm *IAMIDPOIDCConfigWriteModel) AppendEvents(events ...eventstore.Event) {
}
}
func (wm *IAMIDPOIDCConfigWriteModel) Reduce() error {
func (wm *InstanceIDPOIDCConfigWriteModel) Reduce() error {
if err := wm.OIDCConfigWriteModel.Reduce(); err != nil {
return err
}
return wm.WriteModel.Reduce()
}
func (wm *IAMIDPOIDCConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceIDPOIDCConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.AggregateID).
EventTypes(
iam.IDPOIDCConfigAddedEventType,
iam.IDPOIDCConfigChangedEventType,
iam.IDPConfigReactivatedEventType,
iam.IDPConfigDeactivatedEventType,
iam.IDPConfigRemovedEventType).
instance.IDPOIDCConfigAddedEventType,
instance.IDPOIDCConfigChangedEventType,
instance.IDPConfigReactivatedEventType,
instance.IDPConfigDeactivatedEventType,
instance.IDPConfigRemovedEventType).
Builder()
}
func (wm *IAMIDPOIDCConfigWriteModel) NewChangedEvent(
func (wm *InstanceIDPOIDCConfigWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
idpConfigID,
@@ -97,7 +97,7 @@ func (wm *IAMIDPOIDCConfigWriteModel) NewChangedEvent(
idpDisplayNameMapping,
userNameMapping domain.OIDCMappingField,
scopes ...string,
) (*iam.IDPOIDCConfigChangedEvent, bool, error) {
) (*instance.IDPOIDCConfigChangedEvent, bool, error) {
changes := make([]idpconfig.OIDCConfigChanges, 0)
var clientSecret *crypto.CryptoValue
@@ -133,7 +133,7 @@ func (wm *IAMIDPOIDCConfigWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false, nil
}
changeEvent, err := iam.NewIDPOIDCConfigChangedEvent(ctx, aggregate, idpConfigID, changes)
changeEvent, err := instance.NewIDPOIDCConfigChangedEvent(ctx, aggregate, idpConfigID, changes)
if err != nil {
return nil, false, err
}
@@ -13,8 +13,8 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/idpconfig"
"github.com/caos/zitadel/internal/repository/instance"
)
func TestCommandSide_ChangeDefaultIDPOIDCConfig(t *testing.T) {
@@ -78,8 +78,8 @@ func TestCommandSide_ChangeDefaultIDPOIDCConfig(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name1",
domain.IDPConfigTypeOIDC,
@@ -88,8 +88,8 @@ func TestCommandSide_ChangeDefaultIDPOIDCConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPOIDCConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPOIDCConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"clientid1",
"config1",
"issuer",
@@ -107,8 +107,8 @@ func TestCommandSide_ChangeDefaultIDPOIDCConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPConfigRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name",
),
@@ -133,8 +133,8 @@ func TestCommandSide_ChangeDefaultIDPOIDCConfig(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name1",
domain.IDPConfigTypeOIDC,
@@ -143,8 +143,8 @@ func TestCommandSide_ChangeDefaultIDPOIDCConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPOIDCConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPOIDCConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"clientid1",
"config1",
"issuer",
@@ -189,8 +189,8 @@ func TestCommandSide_ChangeDefaultIDPOIDCConfig(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name1",
domain.IDPConfigTypeOIDC,
@@ -199,8 +199,8 @@ func TestCommandSide_ChangeDefaultIDPOIDCConfig(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewIDPOIDCConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPOIDCConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"clientid1",
"config1",
"issuer",
@@ -295,9 +295,9 @@ func TestCommandSide_ChangeDefaultIDPOIDCConfig(t *testing.T) {
}
}
func newDefaultIDPOIDCConfigChangedEvent(ctx context.Context, configID, clientID, issuer, authorizationEndpoint, tokenEndpoint string, secret *crypto.CryptoValue, displayMapping, usernameMapping domain.OIDCMappingField, scopes []string) *iam.IDPOIDCConfigChangedEvent {
event, _ := iam.NewIDPOIDCConfigChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultIDPOIDCConfigChangedEvent(ctx context.Context, configID, clientID, issuer, authorizationEndpoint, tokenEndpoint string, secret *crypto.CryptoValue, displayMapping, usernameMapping domain.OIDCMappingField, scopes []string) *instance.IDPOIDCConfigChangedEvent {
event, _ := instance.NewIDPOIDCConfigChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
configID,
[]idpconfig.OIDCConfigChanges{
idpconfig.ChangeClientID(clientID),
+142
View File
@@ -0,0 +1,142 @@
package command
import (
"context"
"reflect"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/errors"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddInstanceMember(ctx context.Context, member *domain.Member) (*domain.Member, error) {
if member.UserID == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-Mf83b", "Errors.IAM.MemberInvalid")
}
addedMember := NewInstanceMemberWriteModel(member.UserID)
instanceAgg := InstanceAggregateFromWriteModel(&addedMember.MemberWriteModel.WriteModel)
err := c.checkUserExists(ctx, addedMember.UserID, "")
if err != nil {
return nil, caos_errs.ThrowPreconditionFailed(err, "INSTANCE-5N9vs", "Errors.User.NotFound")
}
event, err := c.addInstanceMember(ctx, instanceAgg, addedMember, member)
if err != nil {
return nil, err
}
pushedEvents, err := c.eventstore.Push(ctx, event)
if err != nil {
return nil, err
}
err = AppendAndReduce(addedMember, pushedEvents...)
if err != nil {
return nil, err
}
return memberWriteModelToMember(&addedMember.MemberWriteModel), nil
}
func (c *Commands) addInstanceMember(ctx context.Context, instanceAgg *eventstore.Aggregate, addedMember *InstanceMemberWriteModel, member *domain.Member) (eventstore.Command, error) {
if !member.IsIAMValid() {
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-GR34U", "Errors.IAM.MemberInvalid")
}
if len(domain.CheckForInvalidRoles(member.Roles, domain.IAMRolePrefix, c.zitadelRoles)) > 0 {
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-4m0fS", "Errors.IAM.MemberInvalid")
}
err := c.eventstore.FilterToQueryReducer(ctx, addedMember)
if err != nil {
return nil, err
}
if addedMember.State == domain.MemberStateActive {
return nil, errors.ThrowAlreadyExists(nil, "INSTANCE-sdgQ4", "Errors.IAM.Member.AlreadyExists")
}
return instance.NewMemberAddedEvent(ctx, instanceAgg, member.UserID, member.Roles...), nil
}
//ChangeInstanceMember updates an existing member
func (c *Commands) ChangeInstanceMember(ctx context.Context, member *domain.Member) (*domain.Member, error) {
if !member.IsIAMValid() {
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-LiaZi", "Errors.IAM.MemberInvalid")
}
if len(domain.CheckForInvalidRoles(member.Roles, domain.IAMRolePrefix, c.zitadelRoles)) > 0 {
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-3m9fs", "Errors.IAM.MemberInvalid")
}
existingMember, err := c.instanceMemberWriteModelByID(ctx, member.UserID)
if err != nil {
return nil, err
}
if reflect.DeepEqual(existingMember.Roles, member.Roles) {
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-LiaZi", "Errors.IAM.Member.RolesNotChanged")
}
instanceAgg := InstanceAggregateFromWriteModel(&existingMember.MemberWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewMemberChangedEvent(ctx, instanceAgg, member.UserID, member.Roles...))
if err != nil {
return nil, err
}
err = AppendAndReduce(existingMember, pushedEvents...)
if err != nil {
return nil, err
}
return memberWriteModelToMember(&existingMember.MemberWriteModel), nil
}
func (c *Commands) RemoveInstanceMember(ctx context.Context, userID string) (*domain.ObjectDetails, error) {
if userID == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-LiaZi", "Errors.IDMissing")
}
memberWriteModel, err := c.instanceMemberWriteModelByID(ctx, userID)
if err != nil && !errors.IsNotFound(err) {
return nil, err
}
if errors.IsNotFound(err) {
return nil, nil
}
instanceAgg := InstanceAggregateFromWriteModel(&memberWriteModel.MemberWriteModel.WriteModel)
removeEvent := c.removeInstanceMember(ctx, instanceAgg, userID, false)
pushedEvents, err := c.eventstore.Push(ctx, removeEvent)
if err != nil {
return nil, err
}
err = AppendAndReduce(memberWriteModel, pushedEvents...)
if err != nil {
return nil, err
}
return writeModelToObjectDetails(&memberWriteModel.MemberWriteModel.WriteModel), nil
}
func (c *Commands) removeInstanceMember(ctx context.Context, instanceAgg *eventstore.Aggregate, userID string, cascade bool) eventstore.Command {
if cascade {
return instance.NewMemberCascadeRemovedEvent(
ctx,
instanceAgg,
userID)
} else {
return instance.NewMemberRemovedEvent(ctx, instanceAgg, userID)
}
}
func (c *Commands) instanceMemberWriteModelByID(ctx context.Context, userID string) (member *InstanceMemberWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewInstanceMemberWriteModel(userID)
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
}
if writeModel.State == domain.MemberStateUnspecified || writeModel.State == domain.MemberStateRemoved {
return nil, errors.ThrowNotFound(nil, "INSTANCE-D8JxR", "Errors.NotFound")
}
return writeModel, nil
}
@@ -3,15 +3,15 @@ package command
import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMMemberWriteModel struct {
type InstanceMemberWriteModel struct {
MemberWriteModel
}
func NewIAMMemberWriteModel(userID string) *IAMMemberWriteModel {
return &IAMMemberWriteModel{
func NewInstanceMemberWriteModel(userID string) *InstanceMemberWriteModel {
return &InstanceMemberWriteModel{
MemberWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -22,25 +22,25 @@ func NewIAMMemberWriteModel(userID string) *IAMMemberWriteModel {
}
}
func (wm *IAMMemberWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceMemberWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.MemberAddedEvent:
case *instance.MemberAddedEvent:
if e.UserID != wm.MemberWriteModel.UserID {
continue
}
wm.MemberWriteModel.AppendEvents(&e.MemberAddedEvent)
case *iam.MemberChangedEvent:
case *instance.MemberChangedEvent:
if e.UserID != wm.MemberWriteModel.UserID {
continue
}
wm.MemberWriteModel.AppendEvents(&e.MemberChangedEvent)
case *iam.MemberRemovedEvent:
case *instance.MemberRemovedEvent:
if e.UserID != wm.MemberWriteModel.UserID {
continue
}
wm.MemberWriteModel.AppendEvents(&e.MemberRemovedEvent)
case *iam.MemberCascadeRemovedEvent:
case *instance.MemberCascadeRemovedEvent:
if e.UserID != wm.MemberWriteModel.UserID {
continue
}
@@ -49,20 +49,20 @@ func (wm *IAMMemberWriteModel) AppendEvents(events ...eventstore.Event) {
}
}
func (wm *IAMMemberWriteModel) Reduce() error {
func (wm *InstanceMemberWriteModel) Reduce() error {
return wm.MemberWriteModel.Reduce()
}
func (wm *IAMMemberWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceMemberWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.MemberWriteModel.AggregateID).
EventTypes(
iam.MemberAddedEventType,
iam.MemberChangedEventType,
iam.MemberRemovedEventType,
iam.MemberCascadeRemovedEventType).
instance.MemberAddedEventType,
instance.MemberChangedEventType,
instance.MemberRemovedEventType,
instance.MemberCascadeRemovedEventType).
Builder()
}
@@ -8,7 +8,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/member"
"github.com/caos/zitadel/internal/repository/user"
"github.com/stretchr/testify/assert"
@@ -126,8 +126,8 @@ func TestCommandSide_AddIAMMember(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewMemberAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewMemberAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"user1",
),
),
@@ -174,8 +174,8 @@ func TestCommandSide_AddIAMMember(t *testing.T) {
expectFilter(),
expectPushFailed(caos_errs.ThrowAlreadyExists(nil, "ERROR", "internal"),
[]*repository.Event{
eventFromEventPusher(iam.NewMemberAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
eventFromEventPusher(instance.NewMemberAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"user1",
[]string{"IAM_OWNER"}...,
)),
@@ -224,8 +224,8 @@ func TestCommandSide_AddIAMMember(t *testing.T) {
expectFilter(),
expectPush(
[]*repository.Event{
eventFromEventPusher(iam.NewMemberAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
eventFromEventPusher(instance.NewMemberAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"user1",
[]string{"IAM_OWNER"}...,
)),
@@ -264,7 +264,7 @@ func TestCommandSide_AddIAMMember(t *testing.T) {
eventstore: tt.fields.eventstore,
zitadelRoles: tt.fields.zitadelRoles,
}
got, err := r.AddIAMMember(tt.args.ctx, tt.args.member)
got, err := r.AddInstanceMember(tt.args.ctx, tt.args.member)
if tt.res.err == nil {
assert.NoError(t, err)
}
@@ -361,8 +361,8 @@ func TestCommandSide_ChangeIAMMember(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewMemberAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewMemberAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"user1",
[]string{"IAM_OWNER"}...,
),
@@ -393,8 +393,8 @@ func TestCommandSide_ChangeIAMMember(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewMemberAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewMemberAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"user1",
[]string{"IAM_OWNER"}...,
),
@@ -402,8 +402,8 @@ func TestCommandSide_ChangeIAMMember(t *testing.T) {
),
expectPush(
[]*repository.Event{
eventFromEventPusher(iam.NewMemberChangedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
eventFromEventPusher(instance.NewMemberChangedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"user1",
[]string{"IAM_OWNER", "IAM_OWNER_VIEWER"}...,
)),
@@ -444,7 +444,7 @@ func TestCommandSide_ChangeIAMMember(t *testing.T) {
eventstore: tt.fields.eventstore,
zitadelRoles: tt.fields.zitadelRoles,
}
got, err := r.ChangeIAMMember(tt.args.ctx, tt.args.member)
got, err := r.ChangeInstanceMember(tt.args.ctx, tt.args.member)
if tt.res.err == nil {
assert.NoError(t, err)
}
@@ -514,8 +514,8 @@ func TestCommandSide_RemoveIAMMember(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewMemberAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewMemberAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"user1",
[]string{"IAM_OWNER"}...,
),
@@ -523,8 +523,8 @@ func TestCommandSide_RemoveIAMMember(t *testing.T) {
),
expectPush(
[]*repository.Event{
eventFromEventPusher(iam.NewMemberRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
eventFromEventPusher(instance.NewMemberRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"user1",
)),
},
@@ -548,7 +548,7 @@ func TestCommandSide_RemoveIAMMember(t *testing.T) {
r := &Commands{
eventstore: tt.fields.eventstore,
}
got, err := r.RemoveIAMMember(tt.args.ctx, tt.args.userID)
got, err := r.RemoveInstanceMember(tt.args.ctx, tt.args.userID)
if tt.res.err == nil {
assert.NoError(t, err)
}
@@ -3,11 +3,11 @@ package command
import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"golang.org/x/text/language"
)
type IAMWriteModel struct {
type InstanceWriteModel struct {
eventstore.WriteModel
SetUpStarted domain.Step
@@ -18,8 +18,8 @@ type IAMWriteModel struct {
DefaultLanguage language.Tag
}
func NewIAMWriteModel() *IAMWriteModel {
return &IAMWriteModel{
func NewInstanceWriteModel() *InstanceWriteModel {
return &InstanceWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
ResourceOwner: domain.IAMID,
@@ -27,16 +27,16 @@ func NewIAMWriteModel() *IAMWriteModel {
}
}
func (wm *IAMWriteModel) Reduce() error {
func (wm *InstanceWriteModel) Reduce() error {
for _, event := range wm.Events {
switch e := event.(type) {
case *iam.ProjectSetEvent:
case *instance.ProjectSetEvent:
wm.ProjectID = e.ProjectID
case *iam.GlobalOrgSetEvent:
case *instance.GlobalOrgSetEvent:
wm.GlobalOrgID = e.OrgID
case *iam.DefaultLanguageSetEvent:
case *instance.DefaultLanguageSetEvent:
wm.DefaultLanguage = e.Language
case *iam.SetupStepEvent:
case *instance.SetupStepEvent:
if e.Done {
wm.SetUpDone = e.Step
} else {
@@ -47,21 +47,21 @@ func (wm *IAMWriteModel) Reduce() error {
return nil
}
func (wm *IAMWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.AggregateID).
EventTypes(
iam.ProjectSetEventType,
iam.GlobalOrgSetEventType,
iam.DefaultLanguageSetEventType,
iam.SetupStartedEventType,
iam.SetupDoneEventType).
instance.ProjectSetEventType,
instance.GlobalOrgSetEventType,
instance.DefaultLanguageSetEventType,
instance.SetupStartedEventType,
instance.SetupDoneEventType).
Builder()
}
func IAMAggregateFromWriteModel(wm *eventstore.WriteModel) *eventstore.Aggregate {
return eventstore.AggregateFromWriteModel(wm, iam.AggregateType, iam.AggregateVersion)
func InstanceAggregateFromWriteModel(wm *eventstore.WriteModel) *eventstore.Aggregate {
return eventstore.AggregateFromWriteModel(wm, instance.AggregateType, instance.AggregateVersion)
}
@@ -5,7 +5,7 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
func (c *Commands) AddOIDCSettings(ctx context.Context, settings *domain.OIDCSettings) (*domain.ObjectDetails, error) {
@@ -16,10 +16,10 @@ func (c *Commands) AddOIDCSettings(ctx context.Context, settings *domain.OIDCSet
if oidcSettingWriteModel.State.Exists() {
return nil, caos_errs.ThrowAlreadyExists(nil, "COMMAND-d9nlw", "Errors.OIDCSettings.AlreadyExists")
}
iamAgg := IAMAggregateFromWriteModel(&oidcSettingWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam.NewOIDCSettingsAddedEvent(
instanceAgg := InstanceAggregateFromWriteModel(&oidcSettingWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewOIDCSettingsAddedEvent(
ctx,
iamAgg,
instanceAgg,
settings.AccessTokenLifetime,
settings.IdTokenLifetime,
settings.RefreshTokenIdleExpiration,
@@ -42,11 +42,11 @@ func (c *Commands) ChangeOIDCSettings(ctx context.Context, settings *domain.OIDC
if !oidcSettingWriteModel.State.Exists() {
return nil, caos_errs.ThrowNotFound(nil, "COMMAND-8snEr", "Errors.OIDCSettings.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&oidcSettingWriteModel.WriteModel)
instanceAgg := InstanceAggregateFromWriteModel(&oidcSettingWriteModel.WriteModel)
changedEvent, hasChanged, err := oidcSettingWriteModel.NewChangedEvent(
ctx,
iamAgg,
instanceAgg,
settings.AccessTokenLifetime,
settings.IdTokenLifetime,
settings.RefreshTokenIdleExpiration,
@@ -68,8 +68,8 @@ func (c *Commands) ChangeOIDCSettings(ctx context.Context, settings *domain.OIDC
return writeModelToObjectDetails(&oidcSettingWriteModel.WriteModel), nil
}
func (c *Commands) getOIDCSettings(ctx context.Context) (_ *IAMOIDCSettingsWriteModel, err error) {
writeModel := NewIAMOIDCSettingsWriteModel()
func (c *Commands) getOIDCSettings(ctx context.Context) (_ *InstanceOIDCSettingsWriteModel, err error) {
writeModel := NewInstanceOIDCSettingsWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -6,10 +6,10 @@ import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMOIDCSettingsWriteModel struct {
type InstanceOIDCSettingsWriteModel struct {
eventstore.WriteModel
AccessTokenLifetime time.Duration
@@ -19,8 +19,8 @@ type IAMOIDCSettingsWriteModel struct {
State domain.OIDCSettingsState
}
func NewIAMOIDCSettingsWriteModel() *IAMOIDCSettingsWriteModel {
return &IAMOIDCSettingsWriteModel{
func NewInstanceOIDCSettingsWriteModel() *InstanceOIDCSettingsWriteModel {
return &InstanceOIDCSettingsWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
ResourceOwner: domain.IAMID,
@@ -28,16 +28,16 @@ func NewIAMOIDCSettingsWriteModel() *IAMOIDCSettingsWriteModel {
}
}
func (wm *IAMOIDCSettingsWriteModel) Reduce() error {
func (wm *InstanceOIDCSettingsWriteModel) Reduce() error {
for _, event := range wm.Events {
switch e := event.(type) {
case *iam.OIDCSettingsAddedEvent:
case *instance.OIDCSettingsAddedEvent:
wm.AccessTokenLifetime = e.AccessTokenLifetime
wm.IdTokenLifetime = e.IdTokenLifetime
wm.RefreshTokenIdleExpiration = e.RefreshTokenIdleExpiration
wm.RefreshTokenExpiration = e.RefreshTokenExpiration
wm.State = domain.OIDCSettingsStateActive
case *iam.OIDCSettingsChangedEvent:
case *instance.OIDCSettingsChangedEvent:
if e.AccessTokenLifetime != nil {
wm.AccessTokenLifetime = *e.AccessTokenLifetime
}
@@ -55,45 +55,45 @@ func (wm *IAMOIDCSettingsWriteModel) Reduce() error {
return wm.WriteModel.Reduce()
}
func (wm *IAMOIDCSettingsWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceOIDCSettingsWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.AggregateID).
EventTypes(
iam.OIDCSettingsAddedEventType,
iam.OIDCSettingsChangedEventType).
instance.OIDCSettingsAddedEventType,
instance.OIDCSettingsChangedEventType).
Builder()
}
func (wm *IAMOIDCSettingsWriteModel) NewChangedEvent(
func (wm *InstanceOIDCSettingsWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
accessTokenLifetime,
idTokenLifetime,
refreshTokenIdleExpiration,
refreshTokenExpiration time.Duration,
) (*iam.OIDCSettingsChangedEvent, bool, error) {
changes := make([]iam.OIDCSettingsChanges, 0, 4)
) (*instance.OIDCSettingsChangedEvent, bool, error) {
changes := make([]instance.OIDCSettingsChanges, 0, 4)
var err error
if wm.AccessTokenLifetime != accessTokenLifetime {
changes = append(changes, iam.ChangeOIDCSettingsAccessTokenLifetime(accessTokenLifetime))
changes = append(changes, instance.ChangeOIDCSettingsAccessTokenLifetime(accessTokenLifetime))
}
if wm.IdTokenLifetime != idTokenLifetime {
changes = append(changes, iam.ChangeOIDCSettingsIdTokenLifetime(idTokenLifetime))
changes = append(changes, instance.ChangeOIDCSettingsIdTokenLifetime(idTokenLifetime))
}
if wm.RefreshTokenIdleExpiration != refreshTokenIdleExpiration {
changes = append(changes, iam.ChangeOIDCSettingsRefreshTokenIdleExpiration(refreshTokenIdleExpiration))
changes = append(changes, instance.ChangeOIDCSettingsRefreshTokenIdleExpiration(refreshTokenIdleExpiration))
}
if wm.RefreshTokenExpiration != refreshTokenExpiration {
changes = append(changes, iam.ChangeOIDCSettingsRefreshTokenExpiration(refreshTokenExpiration))
changes = append(changes, instance.ChangeOIDCSettingsRefreshTokenExpiration(refreshTokenExpiration))
}
if len(changes) == 0 {
return nil, false, nil
}
changeEvent, err := iam.NewOIDCSettingsChangeEvent(ctx, aggregate, changes)
changeEvent, err := instance.NewOIDCSettingsChangeEvent(ctx, aggregate, changes)
if err != nil {
return nil, false, err
}
@@ -11,7 +11,7 @@ import (
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
func TestCommandSide_AddOIDCConfig(t *testing.T) {
@@ -39,8 +39,8 @@ func TestCommandSide_AddOIDCConfig(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewOIDCSettingsAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewOIDCSettingsAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
time.Hour*1,
time.Hour*1,
time.Hour*1,
@@ -71,9 +71,9 @@ func TestCommandSide_AddOIDCConfig(t *testing.T) {
expectFilter(),
expectPush(
[]*repository.Event{
eventFromEventPusher(iam.NewOIDCSettingsAddedEvent(
eventFromEventPusher(instance.NewOIDCSettingsAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
time.Hour*1,
time.Hour*1,
time.Hour*1,
@@ -159,9 +159,9 @@ func TestCommandSide_ChangeOIDCConfig(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewOIDCSettingsAddedEvent(
instance.NewOIDCSettingsAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
time.Hour*1,
time.Hour*1,
time.Hour*1,
@@ -191,9 +191,9 @@ func TestCommandSide_ChangeOIDCConfig(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewOIDCSettingsAddedEvent(
instance.NewOIDCSettingsAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
time.Hour*1,
time.Hour*1,
time.Hour*1,
@@ -249,15 +249,15 @@ func TestCommandSide_ChangeOIDCConfig(t *testing.T) {
}
}
func newOIDCConfigChangedEvent(ctx context.Context, accessTokenLifetime, idTokenLifetime, refreshTokenIdleExpiration, refreshTokenExpiration time.Duration) *iam.OIDCSettingsChangedEvent {
changes := []iam.OIDCSettingsChanges{
iam.ChangeOIDCSettingsAccessTokenLifetime(accessTokenLifetime),
iam.ChangeOIDCSettingsIdTokenLifetime(idTokenLifetime),
iam.ChangeOIDCSettingsRefreshTokenIdleExpiration(refreshTokenIdleExpiration),
iam.ChangeOIDCSettingsRefreshTokenExpiration(refreshTokenExpiration),
func newOIDCConfigChangedEvent(ctx context.Context, accessTokenLifetime, idTokenLifetime, refreshTokenIdleExpiration, refreshTokenExpiration time.Duration) *instance.OIDCSettingsChangedEvent {
changes := []instance.OIDCSettingsChanges{
instance.ChangeOIDCSettingsAccessTokenLifetime(accessTokenLifetime),
instance.ChangeOIDCSettingsIdTokenLifetime(idTokenLifetime),
instance.ChangeOIDCSettingsRefreshTokenIdleExpiration(refreshTokenIdleExpiration),
instance.ChangeOIDCSettingsRefreshTokenExpiration(refreshTokenExpiration),
}
event, _ := iam.NewOIDCSettingsChangeEvent(ctx,
&iam.NewAggregate().Aggregate,
event, _ := instance.NewOIDCSettingsChangeEvent(ctx,
&instance.NewAggregate().Aggregate,
changes,
)
return event
@@ -0,0 +1,92 @@
package command
import (
"context"
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddDefaultDomainPolicy(ctx context.Context, policy *domain.DomainPolicy) (*domain.DomainPolicy, error) {
addedPolicy := NewInstanceDomainPolicyWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&addedPolicy.WriteModel)
event, err := c.addDefaultDomainPolicy(ctx, instanceAgg, addedPolicy, policy)
if err != nil {
return nil, err
}
pushedEvents, err := c.eventstore.Push(ctx, event)
if err != nil {
return nil, err
}
err = AppendAndReduce(addedPolicy, pushedEvents...)
if err != nil {
return nil, err
}
return writeModelToDomainPolicy(addedPolicy), nil
}
func (c *Commands) addDefaultDomainPolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, addedPolicy *InstanceDomainPolicyWriteModel, policy *domain.DomainPolicy) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, addedPolicy)
if err != nil {
return nil, err
}
if addedPolicy.State == domain.PolicyStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-Lk0dS", "Errors.IAM.DomainPolicy.AlreadyExists")
}
return iam_repo.NewInstnaceDomainPolicyAddedEvent(ctx, instanceAgg, policy.UserLoginMustBeDomain), nil
}
func (c *Commands) ChangeDefaultDomainPolicy(ctx context.Context, policy *domain.DomainPolicy) (*domain.DomainPolicy, error) {
existingPolicy, err := c.defaultDomainPolicyWriteModelByID(ctx)
if err != nil {
return nil, err
}
if !existingPolicy.State.Exists() {
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-0Pl0d", "Errors.IAM.DomainPolicy.NotFound")
}
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.PolicyDomainWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, instanceAgg, policy.UserLoginMustBeDomain)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
}
pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
if err != nil {
return nil, err
}
err = AppendAndReduce(existingPolicy, pushedEvents...)
if err != nil {
return nil, err
}
return writeModelToDomainPolicy(existingPolicy), nil
}
func (c *Commands) getDefaultDomainPolicy(ctx context.Context) (*domain.DomainPolicy, error) {
policyWriteModel, err := c.defaultDomainPolicyWriteModelByID(ctx)
if err != nil {
return nil, err
}
if !policyWriteModel.State.Exists() {
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-3n8fs", "Errors.IAM.PasswordComplexityPolicy.NotFound")
}
policy := writeModelToDomainPolicy(policyWriteModel)
policy.Default = true
return policy, nil
}
func (c *Commands) defaultDomainPolicyWriteModelByID(ctx context.Context) (policy *InstanceDomainPolicyWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewInstanceDomainPolicyWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
}
return writeModel, nil
}
@@ -0,0 +1,71 @@
package command
import (
"context"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
)
type InstanceDomainPolicyWriteModel struct {
PolicyDomainWriteModel
}
func NewInstanceDomainPolicyWriteModel() *InstanceDomainPolicyWriteModel {
return &InstanceDomainPolicyWriteModel{
PolicyDomainWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
ResourceOwner: domain.IAMID,
},
},
}
}
func (wm *InstanceDomainPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *instance.InstanceDomainPolicyAddedEvent:
wm.PolicyDomainWriteModel.AppendEvents(&e.DomainPolicyAddedEvent)
case *instance.InstanceDomainPolicyChangedEvent:
wm.PolicyDomainWriteModel.AppendEvents(&e.DomainPolicyChangedEvent)
}
}
}
func (wm *InstanceDomainPolicyWriteModel) Reduce() error {
return wm.PolicyDomainWriteModel.Reduce()
}
func (wm *InstanceDomainPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.PolicyDomainWriteModel.AggregateID).
EventTypes(
instance.InstanceDomainPolicyAddedEventType,
instance.InstanceDomainPolicyChangedEventType).
Builder()
}
func (wm *InstanceDomainPolicyWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
userLoginMustBeDomain bool) (*instance.InstanceDomainPolicyChangedEvent, bool) {
changes := make([]policy.OrgPolicyChanges, 0)
if wm.UserLoginMustBeDomain != userLoginMustBeDomain {
changes = append(changes, policy.ChangeUserLoginMustBeDomain(userLoginMustBeDomain))
}
if len(changes) == 0 {
return nil, false
}
changedEvent, err := instance.NewInstanceDomainPolicyChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
return changedEvent, true
}
@@ -2,27 +2,28 @@ package command
import (
"context"
"testing"
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
"github.com/stretchr/testify/assert"
"testing"
)
func TestCommandSide_AddDefaultOrgIAMPolicy(t *testing.T) {
func TestCommandSide_AddDefaultDomainPolicy(t *testing.T) {
type fields struct {
eventstore *eventstore.Eventstore
}
type args struct {
ctx context.Context
policy *domain.OrgIAMPolicy
policy *domain.DomainPolicy
}
type res struct {
want *domain.OrgIAMPolicy
want *domain.DomainPolicy
err func(error) bool
}
tests := []struct {
@@ -38,8 +39,8 @@ func TestCommandSide_AddDefaultOrgIAMPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewOrgIAMPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewInstnaceDomainPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -48,7 +49,7 @@ func TestCommandSide_AddDefaultOrgIAMPolicy(t *testing.T) {
},
args: args{
ctx: context.Background(),
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: true,
},
},
@@ -65,8 +66,8 @@ func TestCommandSide_AddDefaultOrgIAMPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewOrgIAMPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewInstnaceDomainPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -76,12 +77,12 @@ func TestCommandSide_AddDefaultOrgIAMPolicy(t *testing.T) {
},
args: args{
ctx: context.Background(),
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: true,
},
},
res: res{
want: &domain.OrgIAMPolicy{
want: &domain.DomainPolicy{
ObjectRoot: models.ObjectRoot{
AggregateID: "IAM",
ResourceOwner: "IAM",
@@ -96,7 +97,7 @@ func TestCommandSide_AddDefaultOrgIAMPolicy(t *testing.T) {
r := &Commands{
eventstore: tt.fields.eventstore,
}
got, err := r.AddDefaultOrgIAMPolicy(tt.args.ctx, tt.args.policy)
got, err := r.AddDefaultDomainPolicy(tt.args.ctx, tt.args.policy)
if tt.res.err == nil {
assert.NoError(t, err)
}
@@ -116,10 +117,10 @@ func TestCommandSide_ChangeDefaultOrgIAMPolicy(t *testing.T) {
}
type args struct {
ctx context.Context
policy *domain.OrgIAMPolicy
policy *domain.DomainPolicy
}
type res struct {
want *domain.OrgIAMPolicy
want *domain.DomainPolicy
err func(error) bool
}
tests := []struct {
@@ -138,7 +139,7 @@ func TestCommandSide_ChangeDefaultOrgIAMPolicy(t *testing.T) {
},
args: args{
ctx: context.Background(),
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: true,
},
},
@@ -153,8 +154,8 @@ func TestCommandSide_ChangeDefaultOrgIAMPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewOrgIAMPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewInstnaceDomainPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -163,7 +164,7 @@ func TestCommandSide_ChangeDefaultOrgIAMPolicy(t *testing.T) {
},
args: args{
ctx: context.Background(),
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: true,
},
},
@@ -178,8 +179,8 @@ func TestCommandSide_ChangeDefaultOrgIAMPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewOrgIAMPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewInstnaceDomainPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
),
),
@@ -195,12 +196,12 @@ func TestCommandSide_ChangeDefaultOrgIAMPolicy(t *testing.T) {
},
args: args{
ctx: context.Background(),
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: false,
},
},
res: res{
want: &domain.OrgIAMPolicy{
want: &domain.DomainPolicy{
ObjectRoot: models.ObjectRoot{
AggregateID: "IAM",
ResourceOwner: "IAM",
@@ -215,7 +216,7 @@ func TestCommandSide_ChangeDefaultOrgIAMPolicy(t *testing.T) {
r := &Commands{
eventstore: tt.fields.eventstore,
}
got, err := r.ChangeDefaultOrgIAMPolicy(tt.args.ctx, tt.args.policy)
got, err := r.ChangeDefaultDomainPolicy(tt.args.ctx, tt.args.policy)
if tt.res.err == nil {
assert.NoError(t, err)
}
@@ -229,10 +230,10 @@ func TestCommandSide_ChangeDefaultOrgIAMPolicy(t *testing.T) {
}
}
func newDefaultOrgIAMPolicyChangedEvent(ctx context.Context, userLoginMustBeDomain bool) *iam.OrgIAMPolicyChangedEvent {
event, _ := iam.NewOrgIAMPolicyChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
[]policy.OrgIAMPolicyChanges{
func newDefaultOrgIAMPolicyChangedEvent(ctx context.Context, userLoginMustBeDomain bool) *instance.InstanceDomainPolicyChangedEvent {
event, _ := instance.NewInstanceDomainPolicyChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
[]policy.OrgPolicyChanges{
policy.ChangeUserLoginMustBeDomain(userLoginMustBeDomain),
},
)
@@ -6,14 +6,14 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddDefaultLabelPolicy(ctx context.Context, policy *domain.LabelPolicy) (*domain.LabelPolicy, error) {
addedPolicy := NewIAMLabelPolicyWriteModel()
iamAgg := IAMAggregateFromWriteModel(&addedPolicy.LabelPolicyWriteModel.WriteModel)
event, err := c.addDefaultLabelPolicy(ctx, iamAgg, addedPolicy, policy)
addedPolicy := NewInstanceLabelPolicyWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&addedPolicy.LabelPolicyWriteModel.WriteModel)
event, err := c.addDefaultLabelPolicy(ctx, instanceAgg, addedPolicy, policy)
if err != nil {
return nil, err
}
@@ -29,7 +29,7 @@ func (c *Commands) AddDefaultLabelPolicy(ctx context.Context, policy *domain.Lab
return writeModelToLabelPolicy(&addedPolicy.LabelPolicyWriteModel), nil
}
func (c *Commands) addDefaultLabelPolicy(ctx context.Context, iamAgg *eventstore.Aggregate, addedPolicy *IAMLabelPolicyWriteModel, policy *domain.LabelPolicy) (eventstore.Command, error) {
func (c *Commands) addDefaultLabelPolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, addedPolicy *InstanceLabelPolicyWriteModel, policy *domain.LabelPolicy) (eventstore.Command, error) {
if err := policy.IsValid(); err != nil {
return nil, err
}
@@ -38,12 +38,12 @@ func (c *Commands) addDefaultLabelPolicy(ctx context.Context, iamAgg *eventstore
return nil, err
}
if addedPolicy.State == domain.PolicyStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-2B0ps", "Errors.IAM.LabelPolicy.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-2B0ps", "Errors.IAM.LabelPolicy.AlreadyExists")
}
return iam_repo.NewLabelPolicyAddedEvent(
return instance.NewLabelPolicyAddedEvent(
ctx,
iamAgg,
instanceAgg,
policy.PrimaryColor,
policy.BackgroundColor,
policy.WarnColor,
@@ -68,12 +68,12 @@ func (c *Commands) ChangeDefaultLabelPolicy(ctx context.Context, policy *domain.
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-0K9dq", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-0K9dq", "Errors.IAM.LabelPolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(
ctx,
iamAgg,
instanceAgg,
policy.PrimaryColor,
policy.BackgroundColor,
policy.WarnColor,
@@ -86,7 +86,7 @@ func (c *Commands) ChangeDefaultLabelPolicy(ctx context.Context, policy *domain.
policy.ErrorMsgPopup,
policy.DisableWatermark)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
}
pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
@@ -107,11 +107,11 @@ func (c *Commands) ActivateDefaultLabelPolicy(ctx context.Context) (*domain.Obje
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-6M23e", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-6M23e", "Errors.IAM.LabelPolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyActivatedEvent(ctx, iamAgg))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyActivatedEvent(ctx, instanceAgg))
if err != nil {
return nil, err
}
@@ -125,7 +125,7 @@ func (c *Commands) ActivateDefaultLabelPolicy(ctx context.Context) (*domain.Obje
func (c *Commands) AddLogoDefaultLabelPolicy(ctx context.Context, storageKey string) (*domain.ObjectDetails, error) {
if storageKey == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-3m20c", "Errors.Assets.EmptyKey")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-3m20c", "Errors.Assets.EmptyKey")
}
existingPolicy, err := c.defaultLabelPolicyWriteModelByID(ctx)
if err != nil {
@@ -133,10 +133,10 @@ func (c *Commands) AddLogoDefaultLabelPolicy(ctx context.Context, storageKey str
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-Qw0pd", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-Qw0pd", "Errors.IAM.LabelPolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyLogoAddedEvent(ctx, iamAgg, storageKey))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyLogoAddedEvent(ctx, instanceAgg, storageKey))
if err != nil {
return nil, err
}
@@ -154,15 +154,15 @@ func (c *Commands) RemoveLogoDefaultLabelPolicy(ctx context.Context) (*domain.Ob
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-Xc8Kf", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-Xc8Kf", "Errors.IAM.LabelPolicy.NotFound")
}
err = c.RemoveAsset(ctx, domain.IAMID, existingPolicy.LogoKey)
if err != nil {
return nil, err
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyLogoRemovedEvent(ctx, iamAgg, existingPolicy.LogoKey))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyLogoRemovedEvent(ctx, instanceAgg, existingPolicy.LogoKey))
if err != nil {
return nil, err
}
@@ -175,7 +175,7 @@ func (c *Commands) RemoveLogoDefaultLabelPolicy(ctx context.Context) (*domain.Ob
func (c *Commands) AddIconDefaultLabelPolicy(ctx context.Context, storageKey string) (*domain.ObjectDetails, error) {
if storageKey == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-yxE4f", "Errors.Assets.EmptyKey")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-yxE4f", "Errors.Assets.EmptyKey")
}
existingPolicy, err := c.defaultLabelPolicyWriteModelByID(ctx)
if err != nil {
@@ -183,10 +183,10 @@ func (c *Commands) AddIconDefaultLabelPolicy(ctx context.Context, storageKey str
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-1yMx0", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-1yMx0", "Errors.IAM.LabelPolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyIconAddedEvent(ctx, iamAgg, storageKey))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyIconAddedEvent(ctx, instanceAgg, storageKey))
if err != nil {
return nil, err
}
@@ -204,14 +204,14 @@ func (c *Commands) RemoveIconDefaultLabelPolicy(ctx context.Context) (*domain.Ob
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-4M0qw", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-4M0qw", "Errors.IAM.LabelPolicy.NotFound")
}
err = c.RemoveAsset(ctx, domain.IAMID, existingPolicy.IconKey)
if err != nil {
return nil, err
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyIconRemovedEvent(ctx, iamAgg, existingPolicy.IconKey))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyIconRemovedEvent(ctx, instanceAgg, existingPolicy.IconKey))
if err != nil {
return nil, err
}
@@ -224,7 +224,7 @@ func (c *Commands) RemoveIconDefaultLabelPolicy(ctx context.Context) (*domain.Ob
func (c *Commands) AddLogoDarkDefaultLabelPolicy(ctx context.Context, storageKey string) (*domain.ObjectDetails, error) {
if storageKey == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-4fMs9", "Errors.Assets.EmptyKey")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-4fMs9", "Errors.Assets.EmptyKey")
}
existingPolicy, err := c.defaultLabelPolicyWriteModelByID(ctx)
if err != nil {
@@ -232,10 +232,10 @@ func (c *Commands) AddLogoDarkDefaultLabelPolicy(ctx context.Context, storageKey
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-ZR9fs", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-ZR9fs", "Errors.IAM.LabelPolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyLogoDarkAddedEvent(ctx, iamAgg, storageKey))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyLogoDarkAddedEvent(ctx, instanceAgg, storageKey))
if err != nil {
return nil, err
}
@@ -253,14 +253,14 @@ func (c *Commands) RemoveLogoDarkDefaultLabelPolicy(ctx context.Context) (*domai
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-3FGds", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-3FGds", "Errors.IAM.LabelPolicy.NotFound")
}
err = c.RemoveAsset(ctx, domain.IAMID, existingPolicy.LogoDarkKey)
if err != nil {
return nil, err
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyLogoDarkRemovedEvent(ctx, iamAgg, existingPolicy.LogoDarkKey))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyLogoDarkRemovedEvent(ctx, instanceAgg, existingPolicy.LogoDarkKey))
if err != nil {
return nil, err
}
@@ -273,7 +273,7 @@ func (c *Commands) RemoveLogoDarkDefaultLabelPolicy(ctx context.Context) (*domai
func (c *Commands) AddIconDarkDefaultLabelPolicy(ctx context.Context, storageKey string) (*domain.ObjectDetails, error) {
if storageKey == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-1cxM3", "Errors.Assets.EmptyKey")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-1cxM3", "Errors.Assets.EmptyKey")
}
existingPolicy, err := c.defaultLabelPolicyWriteModelByID(ctx)
if err != nil {
@@ -281,10 +281,10 @@ func (c *Commands) AddIconDarkDefaultLabelPolicy(ctx context.Context, storageKey
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-vMsf9", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-vMsf9", "Errors.IAM.LabelPolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyIconDarkAddedEvent(ctx, iamAgg, storageKey))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyIconDarkAddedEvent(ctx, instanceAgg, storageKey))
if err != nil {
return nil, err
}
@@ -302,14 +302,14 @@ func (c *Commands) RemoveIconDarkDefaultLabelPolicy(ctx context.Context) (*domai
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-2nc7F", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-2nc7F", "Errors.IAM.LabelPolicy.NotFound")
}
err = c.RemoveAsset(ctx, domain.IAMID, existingPolicy.IconDarkKey)
if err != nil {
return nil, err
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyIconDarkRemovedEvent(ctx, iamAgg, existingPolicy.IconDarkKey))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyIconDarkRemovedEvent(ctx, instanceAgg, existingPolicy.IconDarkKey))
if err != nil {
return nil, err
}
@@ -322,7 +322,7 @@ func (c *Commands) RemoveIconDarkDefaultLabelPolicy(ctx context.Context) (*domai
func (c *Commands) AddFontDefaultLabelPolicy(ctx context.Context, storageKey string) (*domain.ObjectDetails, error) {
if storageKey == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-1N8fs", "Errors.Assets.EmptyKey")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-1N8fs", "Errors.Assets.EmptyKey")
}
existingPolicy, err := c.defaultLabelPolicyWriteModelByID(ctx)
if err != nil {
@@ -330,10 +330,10 @@ func (c *Commands) AddFontDefaultLabelPolicy(ctx context.Context, storageKey str
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-1N8fE", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-1N8fE", "Errors.IAM.LabelPolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyFontAddedEvent(ctx, iamAgg, storageKey))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyFontAddedEvent(ctx, instanceAgg, storageKey))
if err != nil {
return nil, err
}
@@ -351,14 +351,14 @@ func (c *Commands) RemoveFontDefaultLabelPolicy(ctx context.Context) (*domain.Ob
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-Tk0gw", "Errors.IAM.LabelPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-Tk0gw", "Errors.IAM.LabelPolicy.NotFound")
}
err = c.RemoveAsset(ctx, domain.IAMID, existingPolicy.FontKey)
if err != nil {
return nil, err
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLabelPolicyFontRemovedEvent(ctx, iamAgg, existingPolicy.FontKey))
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LabelPolicyWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLabelPolicyFontRemovedEvent(ctx, instanceAgg, existingPolicy.FontKey))
if err != nil {
return nil, err
}
@@ -369,11 +369,11 @@ func (c *Commands) RemoveFontDefaultLabelPolicy(ctx context.Context) (*domain.Ob
return writeModelToObjectDetails(&existingPolicy.LabelPolicyWriteModel.WriteModel), nil
}
func (c *Commands) defaultLabelPolicyWriteModelByID(ctx context.Context) (policy *IAMLabelPolicyWriteModel, err error) {
func (c *Commands) defaultLabelPolicyWriteModelByID(ctx context.Context) (policy *InstanceLabelPolicyWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMLabelPolicyWriteModel()
writeModel := NewInstanceLabelPolicyWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -5,16 +5,16 @@ import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMLabelPolicyWriteModel struct {
type InstanceLabelPolicyWriteModel struct {
LabelPolicyWriteModel
}
func NewIAMLabelPolicyWriteModel() *IAMLabelPolicyWriteModel {
return &IAMLabelPolicyWriteModel{
func NewInstanceLabelPolicyWriteModel() *InstanceLabelPolicyWriteModel {
return &InstanceLabelPolicyWriteModel{
LabelPolicyWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -24,66 +24,66 @@ func NewIAMLabelPolicyWriteModel() *IAMLabelPolicyWriteModel {
}
}
func (wm *IAMLabelPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceLabelPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.LabelPolicyAddedEvent:
case *instance.LabelPolicyAddedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyAddedEvent)
case *iam.LabelPolicyChangedEvent:
case *instance.LabelPolicyChangedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyChangedEvent)
case *iam.LabelPolicyActivatedEvent:
case *instance.LabelPolicyActivatedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyActivatedEvent)
case *iam.LabelPolicyLogoAddedEvent:
case *instance.LabelPolicyLogoAddedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyLogoAddedEvent)
case *iam.LabelPolicyLogoRemovedEvent:
case *instance.LabelPolicyLogoRemovedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyLogoRemovedEvent)
case *iam.LabelPolicyLogoDarkAddedEvent:
case *instance.LabelPolicyLogoDarkAddedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyLogoDarkAddedEvent)
case *iam.LabelPolicyLogoDarkRemovedEvent:
case *instance.LabelPolicyLogoDarkRemovedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyLogoDarkRemovedEvent)
case *iam.LabelPolicyIconAddedEvent:
case *instance.LabelPolicyIconAddedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyIconAddedEvent)
case *iam.LabelPolicyIconRemovedEvent:
case *instance.LabelPolicyIconRemovedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyIconRemovedEvent)
case *iam.LabelPolicyIconDarkAddedEvent:
case *instance.LabelPolicyIconDarkAddedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyIconDarkAddedEvent)
case *iam.LabelPolicyIconDarkRemovedEvent:
case *instance.LabelPolicyIconDarkRemovedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyIconDarkRemovedEvent)
case *iam.LabelPolicyFontAddedEvent:
case *instance.LabelPolicyFontAddedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyFontAddedEvent)
case *iam.LabelPolicyFontRemovedEvent:
case *instance.LabelPolicyFontRemovedEvent:
wm.LabelPolicyWriteModel.AppendEvents(&e.LabelPolicyFontRemovedEvent)
}
}
}
func (wm *IAMLabelPolicyWriteModel) Reduce() error {
func (wm *InstanceLabelPolicyWriteModel) Reduce() error {
return wm.LabelPolicyWriteModel.Reduce()
}
func (wm *IAMLabelPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceLabelPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.LabelPolicyWriteModel.AggregateID).
EventTypes(
iam.LabelPolicyAddedEventType,
iam.LabelPolicyChangedEventType,
iam.LabelPolicyLogoAddedEventType,
iam.LabelPolicyLogoRemovedEventType,
iam.LabelPolicyIconAddedEventType,
iam.LabelPolicyIconRemovedEventType,
iam.LabelPolicyLogoDarkAddedEventType,
iam.LabelPolicyLogoDarkRemovedEventType,
iam.LabelPolicyIconDarkAddedEventType,
iam.LabelPolicyIconDarkRemovedEventType,
iam.LabelPolicyFontAddedEventType,
iam.LabelPolicyFontRemovedEventType).
instance.LabelPolicyAddedEventType,
instance.LabelPolicyChangedEventType,
instance.LabelPolicyLogoAddedEventType,
instance.LabelPolicyLogoRemovedEventType,
instance.LabelPolicyIconAddedEventType,
instance.LabelPolicyIconRemovedEventType,
instance.LabelPolicyLogoDarkAddedEventType,
instance.LabelPolicyLogoDarkRemovedEventType,
instance.LabelPolicyIconDarkAddedEventType,
instance.LabelPolicyIconDarkRemovedEventType,
instance.LabelPolicyFontAddedEventType,
instance.LabelPolicyFontRemovedEventType).
Builder()
}
func (wm *IAMLabelPolicyWriteModel) NewChangedEvent(
func (wm *InstanceLabelPolicyWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
primaryColor,
@@ -97,7 +97,7 @@ func (wm *IAMLabelPolicyWriteModel) NewChangedEvent(
hideLoginNameSuffix,
errorMsgPopup,
disableWatermark bool,
) (*iam.LabelPolicyChangedEvent, bool) {
) (*instance.LabelPolicyChangedEvent, bool) {
changes := make([]policy.LabelPolicyChanges, 0)
if wm.PrimaryColor != primaryColor {
changes = append(changes, policy.ChangePrimaryColor(primaryColor))
@@ -135,7 +135,7 @@ func (wm *IAMLabelPolicyWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewLabelPolicyChangedEvent(ctx, aggregate, changes)
changedEvent, err := instance.NewLabelPolicyChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
@@ -12,7 +12,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
"github.com/caos/zitadel/internal/static"
"github.com/caos/zitadel/internal/static/mock"
@@ -43,8 +43,8 @@ func TestCommandSide_AddDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -90,8 +90,8 @@ func TestCommandSide_AddDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -210,8 +210,8 @@ func TestCommandSide_ChangeDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -255,8 +255,8 @@ func TestCommandSide_ChangeDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -387,8 +387,8 @@ func TestCommandSide_ActivateDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -406,8 +406,8 @@ func TestCommandSide_ActivateDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyActivatedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyActivatedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
),
),
},
@@ -499,8 +499,8 @@ func TestCommandSide_AddLogoDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -518,8 +518,8 @@ func TestCommandSide_AddLogoDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyLogoAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyLogoAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -599,8 +599,8 @@ func TestCommandSide_RemoveLogoDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -615,8 +615,8 @@ func TestCommandSide_RemoveLogoDefaultLabelPolicy(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewLabelPolicyLogoAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyLogoAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -638,8 +638,8 @@ func TestCommandSide_RemoveLogoDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -654,8 +654,8 @@ func TestCommandSide_RemoveLogoDefaultLabelPolicy(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewLabelPolicyLogoAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyLogoAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -663,8 +663,8 @@ func TestCommandSide_RemoveLogoDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyLogoRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyLogoRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -757,8 +757,8 @@ func TestCommandSide_AddIconDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -776,8 +776,8 @@ func TestCommandSide_AddIconDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyIconAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyIconAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -856,8 +856,8 @@ func TestCommandSide_RemoveIconDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -872,8 +872,8 @@ func TestCommandSide_RemoveIconDefaultLabelPolicy(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewLabelPolicyIconAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyIconAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -881,8 +881,8 @@ func TestCommandSide_RemoveIconDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyIconRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyIconRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -975,8 +975,8 @@ func TestCommandSide_AddLogoDarkDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -994,8 +994,8 @@ func TestCommandSide_AddLogoDarkDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyLogoDarkAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyLogoDarkAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1074,8 +1074,8 @@ func TestCommandSide_RemoveLogoDarkDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -1090,8 +1090,8 @@ func TestCommandSide_RemoveLogoDarkDefaultLabelPolicy(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewLabelPolicyLogoDarkAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyLogoDarkAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1113,8 +1113,8 @@ func TestCommandSide_RemoveLogoDarkDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -1129,8 +1129,8 @@ func TestCommandSide_RemoveLogoDarkDefaultLabelPolicy(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewLabelPolicyLogoDarkAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyLogoDarkAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1138,8 +1138,8 @@ func TestCommandSide_RemoveLogoDarkDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyLogoDarkRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyLogoDarkRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1232,8 +1232,8 @@ func TestCommandSide_AddIconDarkDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -1251,8 +1251,8 @@ func TestCommandSide_AddIconDarkDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyIconDarkAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyIconDarkAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1331,8 +1331,8 @@ func TestCommandSide_RemoveIconDarkDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -1347,8 +1347,8 @@ func TestCommandSide_RemoveIconDarkDefaultLabelPolicy(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewLabelPolicyIconDarkAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyIconDarkAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1370,8 +1370,8 @@ func TestCommandSide_RemoveIconDarkDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -1386,8 +1386,8 @@ func TestCommandSide_RemoveIconDarkDefaultLabelPolicy(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewLabelPolicyIconDarkAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyIconDarkAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1395,8 +1395,8 @@ func TestCommandSide_RemoveIconDarkDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyIconDarkRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyIconDarkRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1489,8 +1489,8 @@ func TestCommandSide_AddFontDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -1508,8 +1508,8 @@ func TestCommandSide_AddFontDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyFontAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyFontAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1588,8 +1588,8 @@ func TestCommandSide_RemoveFontDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -1604,8 +1604,8 @@ func TestCommandSide_RemoveFontDefaultLabelPolicy(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewLabelPolicyFontAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyFontAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1627,8 +1627,8 @@ func TestCommandSide_RemoveFontDefaultLabelPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -1643,8 +1643,8 @@ func TestCommandSide_RemoveFontDefaultLabelPolicy(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewLabelPolicyFontAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyFontAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1652,8 +1652,8 @@ func TestCommandSide_RemoveFontDefaultLabelPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLabelPolicyFontRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyFontRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"key",
),
),
@@ -1691,9 +1691,9 @@ func TestCommandSide_RemoveFontDefaultLabelPolicy(t *testing.T) {
}
}
func newDefaultLabelPolicyChangedEvent(ctx context.Context, primaryColor, backgroundColor, warnColor, fontColor, primaryColorDark, backgroundColorDark, warnColorDark, fontColorDark string, hideLoginNameSuffix, errMsgPopup, disableWatermark bool) *iam.LabelPolicyChangedEvent {
event, _ := iam.NewLabelPolicyChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultLabelPolicyChangedEvent(ctx context.Context, primaryColor, backgroundColor, warnColor, fontColor, primaryColorDark, backgroundColorDark, warnColorDark, fontColorDark string, hideLoginNameSuffix, errMsgPopup, disableWatermark bool) *instance.LabelPolicyChangedEvent {
event, _ := instance.NewLabelPolicyChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
[]policy.LabelPolicyChanges{
policy.ChangePrimaryColor(primaryColor),
policy.ChangeBackgroundColor(backgroundColor),
@@ -7,12 +7,12 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) getDefaultLoginPolicy(ctx context.Context) (*domain.LoginPolicy, error) {
policyWriteModel := NewIAMLoginPolicyWriteModel()
policyWriteModel := NewInstanceLoginPolicyWriteModel()
err := c.eventstore.FilterToQueryReducer(ctx, policyWriteModel)
if err != nil {
return nil, err
@@ -23,9 +23,9 @@ func (c *Commands) getDefaultLoginPolicy(ctx context.Context) (*domain.LoginPoli
}
func (c *Commands) AddDefaultLoginPolicy(ctx context.Context, policy *domain.LoginPolicy) (*domain.LoginPolicy, error) {
addedPolicy := NewIAMLoginPolicyWriteModel()
iamAgg := IAMAggregateFromWriteModel(&addedPolicy.WriteModel)
event, err := c.addDefaultLoginPolicy(ctx, iamAgg, addedPolicy, policy)
addedPolicy := NewInstanceLoginPolicyWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&addedPolicy.WriteModel)
event, err := c.addDefaultLoginPolicy(ctx, instanceAgg, addedPolicy, policy)
if err != nil {
return nil, err
}
@@ -40,17 +40,17 @@ func (c *Commands) AddDefaultLoginPolicy(ctx context.Context, policy *domain.Log
return writeModelToLoginPolicy(&addedPolicy.LoginPolicyWriteModel), nil
}
func (c *Commands) addDefaultLoginPolicy(ctx context.Context, iamAgg *eventstore.Aggregate, addedPolicy *IAMLoginPolicyWriteModel, policy *domain.LoginPolicy) (eventstore.Command, error) {
func (c *Commands) addDefaultLoginPolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, addedPolicy *InstanceLoginPolicyWriteModel, policy *domain.LoginPolicy) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, addedPolicy)
if err != nil {
return nil, err
}
if addedPolicy.State == domain.PolicyStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-2B0ps", "Errors.IAM.LoginPolicy.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-2B0ps", "Errors.IAM.LoginPolicy.AlreadyExists")
}
return iam_repo.NewLoginPolicyAddedEvent(ctx,
iamAgg,
return instance.NewLoginPolicyAddedEvent(ctx,
instanceAgg,
policy.AllowUsernamePassword,
policy.AllowRegister,
policy.AllowExternalIDP,
@@ -65,9 +65,9 @@ func (c *Commands) addDefaultLoginPolicy(ctx context.Context, iamAgg *eventstore
}
func (c *Commands) ChangeDefaultLoginPolicy(ctx context.Context, policy *domain.LoginPolicy) (*domain.LoginPolicy, error) {
existingPolicy := NewIAMLoginPolicyWriteModel()
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LoginPolicyWriteModel.WriteModel)
event, err := c.changeDefaultLoginPolicy(ctx, iamAgg, existingPolicy, policy)
existingPolicy := NewInstanceLoginPolicyWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LoginPolicyWriteModel.WriteModel)
event, err := c.changeDefaultLoginPolicy(ctx, instanceAgg, existingPolicy, policy)
if err != nil {
return nil, err
}
@@ -82,16 +82,16 @@ func (c *Commands) ChangeDefaultLoginPolicy(ctx context.Context, policy *domain.
return writeModelToLoginPolicy(&existingPolicy.LoginPolicyWriteModel), nil
}
func (c *Commands) changeDefaultLoginPolicy(ctx context.Context, iamAgg *eventstore.Aggregate, existingPolicy *IAMLoginPolicyWriteModel, policy *domain.LoginPolicy) (eventstore.Command, error) {
func (c *Commands) changeDefaultLoginPolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, existingPolicy *InstanceLoginPolicyWriteModel, policy *domain.LoginPolicy) (eventstore.Command, error) {
err := c.defaultLoginPolicyWriteModelByID(ctx, existingPolicy)
if err != nil {
return nil, err
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-M0sif", "Errors.IAM.LoginPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-M0sif", "Errors.IAM.LoginPolicy.NotFound")
}
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx,
iamAgg,
instanceAgg,
policy.AllowUsernamePassword,
policy.AllowRegister,
policy.AllowExternalIDP,
@@ -104,39 +104,39 @@ func (c *Commands) changeDefaultLoginPolicy(ctx context.Context, iamAgg *eventst
policy.SecondFactorCheckLifetime,
policy.MultiFactorCheckLifetime)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-5M9vdd", "Errors.IAM.LoginPolicy.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-5M9vdd", "Errors.IAM.LoginPolicy.NotChanged")
}
return changedEvent, nil
}
func (c *Commands) AddIDPProviderToDefaultLoginPolicy(ctx context.Context, idpProvider *domain.IDPProvider) (*domain.IDPProvider, error) {
if !idpProvider.IsValid() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-9nf88", "Errors.IAM.LoginPolicy.IDP.Invalid")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-9nf88", "Errors.IAM.LoginPolicy.IDP.Invalid")
}
existingPolicy := NewIAMLoginPolicyWriteModel()
existingPolicy := NewInstanceLoginPolicyWriteModel()
err := c.defaultLoginPolicyWriteModelByID(ctx, existingPolicy)
if err != nil {
return nil, err
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-GVDfe", "Errors.IAM.LoginPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-GVDfe", "Errors.IAM.LoginPolicy.NotFound")
}
_, err = c.getIAMIDPConfigByID(ctx, idpProvider.IDPConfigID)
_, err = c.getInstanceIDPConfigByID(ctx, idpProvider.IDPConfigID)
if err != nil {
return nil, caos_errs.ThrowPreconditionFailed(err, "IAM-m8fsd", "Errors.IDPConfig.NotExisting")
return nil, caos_errs.ThrowPreconditionFailed(err, "INSTANCE-m8fsd", "Errors.IDPConfig.NotExisting")
}
idpModel := NewIAMIdentityProviderWriteModel(idpProvider.IDPConfigID)
idpModel := NewInstanceIdentityProviderWriteModel(idpProvider.IDPConfigID)
err = c.eventstore.FilterToQueryReducer(ctx, idpModel)
if err != nil {
return nil, err
}
if idpModel.State == domain.IdentityProviderStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-2B0ps", "Errors.IAM.LoginPolicy.IDP.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-2B0ps", "Errors.IAM.LoginPolicy.IDP.AlreadyExists")
}
iamAgg := IAMAggregateFromWriteModel(&idpModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewIdentityProviderAddedEvent(ctx, iamAgg, idpProvider.IDPConfigID))
instanceAgg := InstanceAggregateFromWriteModel(&idpModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewIdentityProviderAddedEvent(ctx, instanceAgg, idpProvider.IDPConfigID))
if err != nil {
return nil, err
}
@@ -149,28 +149,28 @@ func (c *Commands) AddIDPProviderToDefaultLoginPolicy(ctx context.Context, idpPr
func (c *Commands) RemoveIDPProviderFromDefaultLoginPolicy(ctx context.Context, idpProvider *domain.IDPProvider, cascadeExternalIDPs ...*domain.UserIDPLink) (*domain.ObjectDetails, error) {
if !idpProvider.IsValid() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-66m9s", "Errors.IAM.LoginPolicy.IDP.Invalid")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-66m9s", "Errors.IAM.LoginPolicy.IDP.Invalid")
}
existingPolicy := NewIAMLoginPolicyWriteModel()
existingPolicy := NewInstanceLoginPolicyWriteModel()
err := c.defaultLoginPolicyWriteModelByID(ctx, existingPolicy)
if err != nil {
return nil, err
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-Dfg4t", "Errors.IAM.LoginPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-Dfg4t", "Errors.IAM.LoginPolicy.NotFound")
}
idpModel := NewIAMIdentityProviderWriteModel(idpProvider.IDPConfigID)
idpModel := NewInstanceIdentityProviderWriteModel(idpProvider.IDPConfigID)
err = c.eventstore.FilterToQueryReducer(ctx, idpModel)
if err != nil {
return nil, err
}
if idpModel.State == domain.IdentityProviderStateUnspecified || idpModel.State == domain.IdentityProviderStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-39fjs", "Errors.IAM.LoginPolicy.IDP.NotExisting")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-39fjs", "Errors.IAM.LoginPolicy.IDP.NotExisting")
}
iamAgg := IAMAggregateFromWriteModel(&idpModel.IdentityProviderWriteModel.WriteModel)
events := c.removeIDPProviderFromDefaultLoginPolicy(ctx, iamAgg, idpProvider, false, cascadeExternalIDPs...)
instanceAgg := InstanceAggregateFromWriteModel(&idpModel.IdentityProviderWriteModel.WriteModel)
events := c.removeIDPProviderFromDefaultLoginPolicy(ctx, instanceAgg, idpProvider, false, cascadeExternalIDPs...)
pushedEvents, err := c.eventstore.Push(ctx, events...)
if err != nil {
return nil, err
@@ -182,12 +182,12 @@ func (c *Commands) RemoveIDPProviderFromDefaultLoginPolicy(ctx context.Context,
return writeModelToObjectDetails(&idpModel.IdentityProviderWriteModel.WriteModel), nil
}
func (c *Commands) removeIDPProviderFromDefaultLoginPolicy(ctx context.Context, iamAgg *eventstore.Aggregate, idpProvider *domain.IDPProvider, cascade bool, cascadeExternalIDPs ...*domain.UserIDPLink) []eventstore.Command {
func (c *Commands) removeIDPProviderFromDefaultLoginPolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, idpProvider *domain.IDPProvider, cascade bool, cascadeExternalIDPs ...*domain.UserIDPLink) []eventstore.Command {
var events []eventstore.Command
if cascade {
events = append(events, iam_repo.NewIdentityProviderCascadeRemovedEvent(ctx, iamAgg, idpProvider.IDPConfigID))
events = append(events, instance.NewIdentityProviderCascadeRemovedEvent(ctx, instanceAgg, idpProvider.IDPConfigID))
} else {
events = append(events, iam_repo.NewIdentityProviderRemovedEvent(ctx, iamAgg, idpProvider.IDPConfigID))
events = append(events, instance.NewIdentityProviderRemovedEvent(ctx, instanceAgg, idpProvider.IDPConfigID))
}
for _, idp := range cascadeExternalIDPs {
@@ -203,11 +203,11 @@ func (c *Commands) removeIDPProviderFromDefaultLoginPolicy(ctx context.Context,
func (c *Commands) AddSecondFactorToDefaultLoginPolicy(ctx context.Context, secondFactor domain.SecondFactorType) (domain.SecondFactorType, *domain.ObjectDetails, error) {
if !secondFactor.Valid() {
return domain.SecondFactorTypeUnspecified, nil, caos_errs.ThrowInvalidArgument(nil, "IAM-5m9fs", "Errors.IAM.LoginPolicy.MFA.Unspecified")
return domain.SecondFactorTypeUnspecified, nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-5m9fs", "Errors.IAM.LoginPolicy.MFA.Unspecified")
}
secondFactorModel := NewIAMSecondFactorWriteModel(secondFactor)
iamAgg := IAMAggregateFromWriteModel(&secondFactorModel.SecondFactorWriteModel.WriteModel)
event, err := c.addSecondFactorToDefaultLoginPolicy(ctx, iamAgg, secondFactorModel, secondFactor)
secondFactorModel := NewInstanceSecondFactorWriteModel(secondFactor)
instanceAgg := InstanceAggregateFromWriteModel(&secondFactorModel.SecondFactorWriteModel.WriteModel)
event, err := c.addSecondFactorToDefaultLoginPolicy(ctx, instanceAgg, secondFactorModel, secondFactor)
if err != nil {
return domain.SecondFactorTypeUnspecified, nil, err
}
@@ -223,32 +223,32 @@ func (c *Commands) AddSecondFactorToDefaultLoginPolicy(ctx context.Context, seco
return secondFactorModel.MFAType, writeModelToObjectDetails(&secondFactorModel.WriteModel), nil
}
func (c *Commands) addSecondFactorToDefaultLoginPolicy(ctx context.Context, iamAgg *eventstore.Aggregate, secondFactorModel *IAMSecondFactorWriteModel, secondFactor domain.SecondFactorType) (eventstore.Command, error) {
func (c *Commands) addSecondFactorToDefaultLoginPolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, secondFactorModel *InstanceSecondFactorWriteModel, secondFactor domain.SecondFactorType) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, secondFactorModel)
if err != nil {
return nil, err
}
if secondFactorModel.State == domain.FactorStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-2B0ps", "Errors.IAM.LoginPolicy.MFA.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-2B0ps", "Errors.IAM.LoginPolicy.MFA.AlreadyExists")
}
return iam_repo.NewLoginPolicySecondFactorAddedEvent(ctx, iamAgg, secondFactor), nil
return instance.NewLoginPolicySecondFactorAddedEvent(ctx, instanceAgg, secondFactor), nil
}
func (c *Commands) RemoveSecondFactorFromDefaultLoginPolicy(ctx context.Context, secondFactor domain.SecondFactorType) (*domain.ObjectDetails, error) {
if !secondFactor.Valid() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-55n8s", "Errors.IAM.LoginPolicy.MFA.Unspecified")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-55n8s", "Errors.IAM.LoginPolicy.MFA.Unspecified")
}
secondFactorModel := NewIAMSecondFactorWriteModel(secondFactor)
secondFactorModel := NewInstanceSecondFactorWriteModel(secondFactor)
err := c.eventstore.FilterToQueryReducer(ctx, secondFactorModel)
if err != nil {
return nil, err
}
if secondFactorModel.State == domain.FactorStateUnspecified || secondFactorModel.State == domain.FactorStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-3M9od", "Errors.IAM.LoginPolicy.MFA.NotExisting")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-3M9od", "Errors.IAM.LoginPolicy.MFA.NotExisting")
}
iamAgg := IAMAggregateFromWriteModel(&secondFactorModel.SecondFactorWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLoginPolicySecondFactorRemovedEvent(ctx, iamAgg, secondFactor))
instanceAgg := InstanceAggregateFromWriteModel(&secondFactorModel.SecondFactorWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLoginPolicySecondFactorRemovedEvent(ctx, instanceAgg, secondFactor))
if err != nil {
return nil, err
}
@@ -261,11 +261,11 @@ func (c *Commands) RemoveSecondFactorFromDefaultLoginPolicy(ctx context.Context,
func (c *Commands) AddMultiFactorToDefaultLoginPolicy(ctx context.Context, multiFactor domain.MultiFactorType) (domain.MultiFactorType, *domain.ObjectDetails, error) {
if !multiFactor.Valid() {
return domain.MultiFactorTypeUnspecified, nil, caos_errs.ThrowInvalidArgument(nil, "IAM-5m9fs", "Errors.IAM.LoginPolicy.MFA.Unspecified")
return domain.MultiFactorTypeUnspecified, nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-5m9fs", "Errors.IAM.LoginPolicy.MFA.Unspecified")
}
multiFactorModel := NewIAMMultiFactorWriteModel(multiFactor)
iamAgg := IAMAggregateFromWriteModel(&multiFactorModel.MultiFactorWriteModel.WriteModel)
event, err := c.addMultiFactorToDefaultLoginPolicy(ctx, iamAgg, multiFactorModel, multiFactor)
multiFactorModel := NewInstanceMultiFactorWriteModel(multiFactor)
instanceAgg := InstanceAggregateFromWriteModel(&multiFactorModel.MultiFactorWriteModel.WriteModel)
event, err := c.addMultiFactorToDefaultLoginPolicy(ctx, instanceAgg, multiFactorModel, multiFactor)
if err != nil {
return domain.MultiFactorTypeUnspecified, nil, err
}
@@ -281,32 +281,32 @@ func (c *Commands) AddMultiFactorToDefaultLoginPolicy(ctx context.Context, multi
return multiFactorModel.MultiFactorWriteModel.MFAType, writeModelToObjectDetails(&multiFactorModel.WriteModel), nil
}
func (c *Commands) addMultiFactorToDefaultLoginPolicy(ctx context.Context, iamAgg *eventstore.Aggregate, multiFactorModel *IAMMultiFactorWriteModel, multiFactor domain.MultiFactorType) (eventstore.Command, error) {
func (c *Commands) addMultiFactorToDefaultLoginPolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, multiFactorModel *InstanceMultiFactorWriteModel, multiFactor domain.MultiFactorType) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, multiFactorModel)
if err != nil {
return nil, err
}
if multiFactorModel.State == domain.FactorStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-3M9od", "Errors.IAM.LoginPolicy.MFA.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-3M9od", "Errors.IAM.LoginPolicy.MFA.AlreadyExists")
}
return iam_repo.NewLoginPolicyMultiFactorAddedEvent(ctx, iamAgg, multiFactor), nil
return instance.NewLoginPolicyMultiFactorAddedEvent(ctx, instanceAgg, multiFactor), nil
}
func (c *Commands) RemoveMultiFactorFromDefaultLoginPolicy(ctx context.Context, multiFactor domain.MultiFactorType) (*domain.ObjectDetails, error) {
if !multiFactor.Valid() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-33m9F", "Errors.IAM.LoginPolicy.MFA.Unspecified")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-33m9F", "Errors.IAM.LoginPolicy.MFA.Unspecified")
}
multiFactorModel := NewIAMMultiFactorWriteModel(multiFactor)
multiFactorModel := NewInstanceMultiFactorWriteModel(multiFactor)
err := c.eventstore.FilterToQueryReducer(ctx, multiFactorModel)
if err != nil {
return nil, err
}
if multiFactorModel.State == domain.FactorStateUnspecified || multiFactorModel.State == domain.FactorStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-3M9df", "Errors.IAM.LoginPolicy.MFA.NotExisting")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-3M9df", "Errors.IAM.LoginPolicy.MFA.NotExisting")
}
iamAgg := IAMAggregateFromWriteModel(&multiFactorModel.MultiFactorWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewLoginPolicyMultiFactorRemovedEvent(ctx, iamAgg, multiFactor))
instanceAgg := InstanceAggregateFromWriteModel(&multiFactorModel.MultiFactorWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewLoginPolicyMultiFactorRemovedEvent(ctx, instanceAgg, multiFactor))
if err != nil {
return nil, err
}
@@ -317,7 +317,7 @@ func (c *Commands) RemoveMultiFactorFromDefaultLoginPolicy(ctx context.Context,
return writeModelToObjectDetails(&multiFactorModel.WriteModel), nil
}
func (c *Commands) defaultLoginPolicyWriteModelByID(ctx context.Context, writeModel *IAMLoginPolicyWriteModel) (err error) {
func (c *Commands) defaultLoginPolicyWriteModelByID(ctx context.Context, writeModel *InstanceLoginPolicyWriteModel) (err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
@@ -3,15 +3,15 @@ package command
import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMSecondFactorWriteModel struct {
type InstanceSecondFactorWriteModel struct {
SecondFactorWriteModel
}
func NewIAMSecondFactorWriteModel(factorType domain.SecondFactorType) *IAMSecondFactorWriteModel {
return &IAMSecondFactorWriteModel{
func NewInstanceSecondFactorWriteModel(factorType domain.SecondFactorType) *InstanceSecondFactorWriteModel {
return &InstanceSecondFactorWriteModel{
SecondFactorWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -22,14 +22,14 @@ func NewIAMSecondFactorWriteModel(factorType domain.SecondFactorType) *IAMSecond
}
}
func (wm *IAMSecondFactorWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceSecondFactorWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.LoginPolicySecondFactorAddedEvent:
case *instance.LoginPolicySecondFactorAddedEvent:
if wm.MFAType == e.MFAType {
wm.WriteModel.AppendEvents(&e.SecondFactorAddedEvent)
}
case *iam.LoginPolicySecondFactorRemovedEvent:
case *instance.LoginPolicySecondFactorRemovedEvent:
if wm.MFAType == e.MFAType {
wm.WriteModel.AppendEvents(&e.SecondFactorRemovedEvent)
}
@@ -37,28 +37,28 @@ func (wm *IAMSecondFactorWriteModel) AppendEvents(events ...eventstore.Event) {
}
}
func (wm *IAMSecondFactorWriteModel) Reduce() error {
func (wm *InstanceSecondFactorWriteModel) Reduce() error {
return wm.SecondFactorWriteModel.Reduce()
}
func (wm *IAMSecondFactorWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceSecondFactorWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.WriteModel.AggregateID).
EventTypes(
iam.LoginPolicySecondFactorAddedEventType,
iam.LoginPolicySecondFactorRemovedEventType).
instance.LoginPolicySecondFactorAddedEventType,
instance.LoginPolicySecondFactorRemovedEventType).
Builder()
}
type IAMMultiFactorWriteModel struct {
type InstanceMultiFactorWriteModel struct {
MultiFactorWriteModel
}
func NewIAMMultiFactorWriteModel(factorType domain.MultiFactorType) *IAMMultiFactorWriteModel {
return &IAMMultiFactorWriteModel{
func NewInstanceMultiFactorWriteModel(factorType domain.MultiFactorType) *InstanceMultiFactorWriteModel {
return &InstanceMultiFactorWriteModel{
MultiFactorWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -69,14 +69,14 @@ func NewIAMMultiFactorWriteModel(factorType domain.MultiFactorType) *IAMMultiFac
}
}
func (wm *IAMMultiFactorWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceMultiFactorWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.LoginPolicyMultiFactorAddedEvent:
case *instance.LoginPolicyMultiFactorAddedEvent:
if wm.MFAType == e.MFAType {
wm.WriteModel.AppendEvents(&e.MultiFactorAddedEvent)
}
case *iam.LoginPolicyMultiFactorRemovedEvent:
case *instance.LoginPolicyMultiFactorRemovedEvent:
if wm.MFAType == e.MFAType {
wm.WriteModel.AppendEvents(&e.MultiFactorRemovedEvent)
}
@@ -84,18 +84,18 @@ func (wm *IAMMultiFactorWriteModel) AppendEvents(events ...eventstore.Event) {
}
}
func (wm *IAMMultiFactorWriteModel) Reduce() error {
func (wm *InstanceMultiFactorWriteModel) Reduce() error {
return wm.MultiFactorWriteModel.Reduce()
}
func (wm *IAMMultiFactorWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceMultiFactorWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.WriteModel.AggregateID).
EventTypes(
iam.LoginPolicyMultiFactorAddedEventType,
iam.LoginPolicyMultiFactorRemovedEventType).
instance.LoginPolicyMultiFactorAddedEventType,
instance.LoginPolicyMultiFactorRemovedEventType).
Builder()
}
@@ -3,15 +3,15 @@ package command
import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMIdentityProviderWriteModel struct {
type InstanceIdentityProviderWriteModel struct {
IdentityProviderWriteModel
}
func NewIAMIdentityProviderWriteModel(idpConfigID string) *IAMIdentityProviderWriteModel {
return &IAMIdentityProviderWriteModel{
func NewInstanceIdentityProviderWriteModel(idpConfigID string) *InstanceIdentityProviderWriteModel {
return &InstanceIdentityProviderWriteModel{
IdentityProviderWriteModel: IdentityProviderWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -22,15 +22,15 @@ func NewIAMIdentityProviderWriteModel(idpConfigID string) *IAMIdentityProviderWr
}
}
func (wm *IAMIdentityProviderWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceIdentityProviderWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.IdentityProviderAddedEvent:
case *instance.IdentityProviderAddedEvent:
if e.IDPConfigID != wm.IDPConfigID {
continue
}
wm.IdentityProviderWriteModel.AppendEvents(&e.IdentityProviderAddedEvent)
case *iam.IdentityProviderRemovedEvent:
case *instance.IdentityProviderRemovedEvent:
if e.IDPConfigID != wm.IDPConfigID {
continue
}
@@ -39,15 +39,15 @@ func (wm *IAMIdentityProviderWriteModel) AppendEvents(events ...eventstore.Event
}
}
func (wm *IAMIdentityProviderWriteModel) Reduce() error {
func (wm *InstanceIdentityProviderWriteModel) Reduce() error {
return wm.IdentityProviderWriteModel.Reduce()
}
func (wm *IAMIdentityProviderWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceIdentityProviderWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.AggregateID).
Builder()
}
@@ -7,16 +7,16 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMLoginPolicyWriteModel struct {
type InstanceLoginPolicyWriteModel struct {
LoginPolicyWriteModel
}
func NewIAMLoginPolicyWriteModel() *IAMLoginPolicyWriteModel {
return &IAMLoginPolicyWriteModel{
func NewInstanceLoginPolicyWriteModel() *InstanceLoginPolicyWriteModel {
return &InstanceLoginPolicyWriteModel{
LoginPolicyWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -26,38 +26,38 @@ func NewIAMLoginPolicyWriteModel() *IAMLoginPolicyWriteModel {
}
}
func (wm *IAMLoginPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceLoginPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.LoginPolicyAddedEvent:
case *instance.LoginPolicyAddedEvent:
wm.LoginPolicyWriteModel.AppendEvents(&e.LoginPolicyAddedEvent)
case *iam.LoginPolicyChangedEvent:
case *instance.LoginPolicyChangedEvent:
wm.LoginPolicyWriteModel.AppendEvents(&e.LoginPolicyChangedEvent)
}
}
}
func (wm *IAMLoginPolicyWriteModel) IsValid() bool {
func (wm *InstanceLoginPolicyWriteModel) IsValid() bool {
return wm.AggregateID != ""
}
func (wm *IAMLoginPolicyWriteModel) Reduce() error {
func (wm *InstanceLoginPolicyWriteModel) Reduce() error {
return wm.LoginPolicyWriteModel.Reduce()
}
func (wm *IAMLoginPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceLoginPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.LoginPolicyWriteModel.AggregateID).
EventTypes(
iam.LoginPolicyAddedEventType,
iam.LoginPolicyChangedEventType).
instance.LoginPolicyAddedEventType,
instance.LoginPolicyChangedEventType).
Builder()
}
func (wm *IAMLoginPolicyWriteModel) NewChangedEvent(
func (wm *InstanceLoginPolicyWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
allowUsernamePassword,
@@ -71,7 +71,7 @@ func (wm *IAMLoginPolicyWriteModel) NewChangedEvent(
mfaInitSkipLifetime,
secondFactorCheckLifetime,
multiFactorCheckLifetime time.Duration,
) (*iam.LoginPolicyChangedEvent, bool) {
) (*instance.LoginPolicyChangedEvent, bool) {
changes := make([]policy.LoginPolicyChanges, 0)
if wm.AllowUserNamePassword != allowUsernamePassword {
@@ -110,7 +110,7 @@ func (wm *IAMLoginPolicyWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewLoginPolicyChangedEvent(ctx, aggregate, changes)
changedEvent, err := instance.NewLoginPolicyChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
@@ -10,7 +10,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
"github.com/caos/zitadel/internal/repository/user"
@@ -42,8 +42,8 @@ func TestCommandSide_AddDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
false,
@@ -81,8 +81,8 @@ func TestCommandSide_AddDefaultLoginPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -200,8 +200,8 @@ func TestCommandSide_ChangeDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -245,8 +245,8 @@ func TestCommandSide_ChangeDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -395,8 +395,8 @@ func TestCommandSide_AddIDPProviderDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -431,8 +431,8 @@ func TestCommandSide_AddIDPProviderDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -449,8 +449,8 @@ func TestCommandSide_AddIDPProviderDefaultLoginPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name",
domain.IDPConfigTypeOIDC,
@@ -461,8 +461,8 @@ func TestCommandSide_AddIDPProviderDefaultLoginPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewIdentityProviderAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIdentityProviderAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
),
),
@@ -486,8 +486,8 @@ func TestCommandSide_AddIDPProviderDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -504,8 +504,8 @@ func TestCommandSide_AddIDPProviderDefaultLoginPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewIDPConfigAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIDPConfigAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
"name",
domain.IDPConfigTypeOIDC,
@@ -518,8 +518,8 @@ func TestCommandSide_AddIDPProviderDefaultLoginPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewIdentityProviderAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIdentityProviderAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1"),
),
},
@@ -621,8 +621,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -657,8 +657,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -675,14 +675,14 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewIdentityProviderAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIdentityProviderAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
),
),
eventFromEventPusher(
iam.NewIdentityProviderRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIdentityProviderRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
),
),
@@ -706,8 +706,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -724,8 +724,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewIdentityProviderAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIdentityProviderAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
),
),
@@ -733,8 +733,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewIdentityProviderRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIdentityProviderRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1"),
),
},
@@ -760,8 +760,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -778,8 +778,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewIdentityProviderAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIdentityProviderAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
),
),
@@ -787,8 +787,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewIdentityProviderRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIdentityProviderRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1"),
),
},
@@ -822,8 +822,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -840,8 +840,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewIdentityProviderAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIdentityProviderAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1",
),
),
@@ -856,8 +856,8 @@ func TestCommandSide_RemoveIDPProviderDefaultLoginPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewIdentityProviderRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewIdentityProviderRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"config1"),
),
eventFromEventPusher(
@@ -950,8 +950,8 @@ func TestCommandSide_AddSecondFactorDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicySecondFactorAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicySecondFactorAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.SecondFactorTypeOTP,
),
),
@@ -975,8 +975,8 @@ func TestCommandSide_AddSecondFactorDefaultLoginPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLoginPolicySecondFactorAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicySecondFactorAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.SecondFactorTypeOTP),
),
},
@@ -1069,14 +1069,14 @@ func TestCommandSide_RemoveSecondFactorDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicySecondFactorAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicySecondFactorAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.SecondFactorTypeOTP,
),
),
eventFromEventPusher(
iam.NewLoginPolicySecondFactorRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicySecondFactorRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.SecondFactorTypeOTP,
),
),
@@ -1098,8 +1098,8 @@ func TestCommandSide_RemoveSecondFactorDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicySecondFactorAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicySecondFactorAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.SecondFactorTypeOTP,
),
),
@@ -1107,8 +1107,8 @@ func TestCommandSide_RemoveSecondFactorDefaultLoginPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLoginPolicySecondFactorRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicySecondFactorRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.SecondFactorTypeOTP),
),
},
@@ -1185,8 +1185,8 @@ func TestCommandSide_AddMultiFactorDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyMultiFactorAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyMultiFactorAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.MultiFactorTypeU2FWithPIN,
),
),
@@ -1210,8 +1210,8 @@ func TestCommandSide_AddMultiFactorDefaultLoginPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLoginPolicyMultiFactorAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyMultiFactorAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.MultiFactorTypeU2FWithPIN),
),
},
@@ -1304,14 +1304,14 @@ func TestCommandSide_RemoveMultiFactorDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyMultiFactorAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyMultiFactorAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.MultiFactorTypeU2FWithPIN,
),
),
eventFromEventPusher(
iam.NewLoginPolicyMultiFactorRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyMultiFactorRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.MultiFactorTypeU2FWithPIN,
),
),
@@ -1333,8 +1333,8 @@ func TestCommandSide_RemoveMultiFactorDefaultLoginPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyMultiFactorAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyMultiFactorAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.MultiFactorTypeU2FWithPIN,
),
),
@@ -1342,8 +1342,8 @@ func TestCommandSide_RemoveMultiFactorDefaultLoginPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLoginPolicyMultiFactorRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyMultiFactorRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.MultiFactorTypeU2FWithPIN),
),
},
@@ -1382,9 +1382,9 @@ func TestCommandSide_RemoveMultiFactorDefaultLoginPolicy(t *testing.T) {
func newDefaultLoginPolicyChangedEvent(ctx context.Context, allowRegister, allowUsernamePassword, allowExternalIDP, forceMFA, hidePasswordReset bool,
passwordlessType domain.PasswordlessType,
passwordLifetime, externalLoginLifetime, mfaInitSkipLifetime, secondFactorLifetime, multiFactorLifetime time.Duration) *iam.LoginPolicyChangedEvent {
event, _ := iam.NewLoginPolicyChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
passwordLifetime, externalLoginLifetime, mfaInitSkipLifetime, secondFactorLifetime, multiFactorLifetime time.Duration) *instance.LoginPolicyChangedEvent {
event, _ := instance.NewLoginPolicyChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
[]policy.LoginPolicyChanges{
policy.ChangeAllowRegister(allowRegister),
policy.ChangeAllowExternalIDP(allowExternalIDP),
@@ -6,14 +6,14 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddDefaultMailTemplate(ctx context.Context, policy *domain.MailTemplate) (*domain.MailTemplate, error) {
addedPolicy := NewIAMMailTemplateWriteModel()
iamAgg := IAMAggregateFromWriteModel(&addedPolicy.MailTemplateWriteModel.WriteModel)
event, err := c.addDefaultMailTemplate(ctx, iamAgg, addedPolicy, policy)
addedPolicy := NewInstanceMailTemplateWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&addedPolicy.MailTemplateWriteModel.WriteModel)
event, err := c.addDefaultMailTemplate(ctx, instanceAgg, addedPolicy, policy)
if err != nil {
return nil, err
}
@@ -29,19 +29,19 @@ func (c *Commands) AddDefaultMailTemplate(ctx context.Context, policy *domain.Ma
return writeModelToMailTemplatePolicy(&addedPolicy.MailTemplateWriteModel), nil
}
func (c *Commands) addDefaultMailTemplate(ctx context.Context, iamAgg *eventstore.Aggregate, addedPolicy *IAMMailTemplateWriteModel, policy *domain.MailTemplate) (eventstore.Command, error) {
func (c *Commands) addDefaultMailTemplate(ctx context.Context, instanceAgg *eventstore.Aggregate, addedPolicy *InstanceMailTemplateWriteModel, policy *domain.MailTemplate) (eventstore.Command, error) {
if !policy.IsValid() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-fm9sd", "Errors.IAM.MailTemplate.Invalid")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-fm9sd", "Errors.IAM.MailTemplate.Invalid")
}
err := c.eventstore.FilterToQueryReducer(ctx, addedPolicy)
if err != nil {
return nil, err
}
if addedPolicy.State == domain.PolicyStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-5n8fs", "Errors.IAM.MailTemplate.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-5n8fs", "Errors.IAM.MailTemplate.AlreadyExists")
}
return iam_repo.NewMailTemplateAddedEvent(ctx, iamAgg, policy.Template), nil
return instance.NewMailTemplateAddedEvent(ctx, instanceAgg, policy.Template), nil
}
func (c *Commands) ChangeDefaultMailTemplate(ctx context.Context, policy *domain.MailTemplate) (*domain.MailTemplate, error) {
@@ -60,9 +60,9 @@ func (c *Commands) ChangeDefaultMailTemplate(ctx context.Context, policy *domain
return writeModelToMailTemplatePolicy(&existingPolicy.MailTemplateWriteModel), nil
}
func (c *Commands) changeDefaultMailTemplate(ctx context.Context, policy *domain.MailTemplate) (*IAMMailTemplateWriteModel, eventstore.Command, error) {
func (c *Commands) changeDefaultMailTemplate(ctx context.Context, policy *domain.MailTemplate) (*InstanceMailTemplateWriteModel, eventstore.Command, error) {
if !policy.IsValid() {
return nil, nil, caos_errs.ThrowInvalidArgument(nil, "IAM-4m9ds", "Errors.IAM.MailTemplate.Invalid")
return nil, nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-4m9ds", "Errors.IAM.MailTemplate.Invalid")
}
existingPolicy, err := c.defaultMailTemplateWriteModelByID(ctx)
if err != nil {
@@ -70,23 +70,23 @@ func (c *Commands) changeDefaultMailTemplate(ctx context.Context, policy *domain
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, nil, caos_errs.ThrowNotFound(nil, "IAM-2N8fs", "Errors.IAM.MailTemplate.NotFound")
return nil, nil, caos_errs.ThrowNotFound(nil, "INSTANCE-2N8fs", "Errors.IAM.MailTemplate.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.MailTemplateWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, iamAgg, policy.Template)
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.MailTemplateWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, instanceAgg, policy.Template)
if !hasChanged {
return nil, nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-3nfsG", "Errors.IAM.MailTemplate.NotChanged")
return nil, nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-3nfsG", "Errors.IAM.MailTemplate.NotChanged")
}
return existingPolicy, changedEvent, nil
}
func (c *Commands) defaultMailTemplateWriteModelByID(ctx context.Context) (policy *IAMMailTemplateWriteModel, err error) {
func (c *Commands) defaultMailTemplateWriteModelByID(ctx context.Context) (policy *InstanceMailTemplateWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMMailTemplateWriteModel()
writeModel := NewInstanceMailTemplateWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -7,16 +7,16 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMMailTemplateWriteModel struct {
type InstanceMailTemplateWriteModel struct {
MailTemplateWriteModel
}
func NewIAMMailTemplateWriteModel() *IAMMailTemplateWriteModel {
return &IAMMailTemplateWriteModel{
func NewInstanceMailTemplateWriteModel() *InstanceMailTemplateWriteModel {
return &InstanceMailTemplateWriteModel{
MailTemplateWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -26,38 +26,38 @@ func NewIAMMailTemplateWriteModel() *IAMMailTemplateWriteModel {
}
}
func (wm *IAMMailTemplateWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceMailTemplateWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.MailTemplateAddedEvent:
case *instance.MailTemplateAddedEvent:
wm.MailTemplateWriteModel.AppendEvents(&e.MailTemplateAddedEvent)
case *iam.MailTemplateChangedEvent:
case *instance.MailTemplateChangedEvent:
wm.MailTemplateWriteModel.AppendEvents(&e.MailTemplateChangedEvent)
}
}
}
func (wm *IAMMailTemplateWriteModel) Reduce() error {
func (wm *InstanceMailTemplateWriteModel) Reduce() error {
return wm.MailTemplateWriteModel.Reduce()
}
func (wm *IAMMailTemplateWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceMailTemplateWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.MailTemplateWriteModel.AggregateID).
EventTypes(
iam.MailTemplateAddedEventType,
iam.MailTemplateChangedEventType).
instance.MailTemplateAddedEventType,
instance.MailTemplateChangedEventType).
Builder()
}
func (wm *IAMMailTemplateWriteModel) NewChangedEvent(
func (wm *InstanceMailTemplateWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
template []byte,
) (*iam.MailTemplateChangedEvent, bool) {
) (*instance.MailTemplateChangedEvent, bool) {
changes := make([]policy.MailTemplateChanges, 0)
if !reflect.DeepEqual(wm.Template, template) {
changes = append(changes, policy.ChangeTemplate(template))
@@ -65,7 +65,7 @@ func (wm *IAMMailTemplateWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewMailTemplateChangedEvent(ctx, aggregate, changes)
changedEvent, err := instance.NewMailTemplateChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
@@ -7,7 +7,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
"github.com/stretchr/testify/assert"
"testing"
@@ -53,8 +53,8 @@ func TestCommandSide_AddDefaultMailTemplatePolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewMailTemplateAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewMailTemplateAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
[]byte("template"),
),
),
@@ -80,8 +80,8 @@ func TestCommandSide_AddDefaultMailTemplatePolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewMailTemplateAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewMailTemplateAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
[]byte("template"),
),
),
@@ -183,8 +183,8 @@ func TestCommandSide_ChangeDefaultMailTemplatePolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewMailTemplateAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewMailTemplateAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
[]byte("template"),
),
),
@@ -208,8 +208,8 @@ func TestCommandSide_ChangeDefaultMailTemplatePolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewMailTemplateAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewMailTemplateAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
[]byte("template"),
),
),
@@ -259,9 +259,9 @@ func TestCommandSide_ChangeDefaultMailTemplatePolicy(t *testing.T) {
}
}
func newDefaultMailTemplatePolicyChangedEvent(ctx context.Context, template []byte) *iam.MailTemplateChangedEvent {
event, _ := iam.NewMailTemplateChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultMailTemplatePolicyChangedEvent(ctx context.Context, template []byte) *instance.MailTemplateChangedEvent {
event, _ := instance.NewMailTemplateChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
[]policy.MailTemplateChanges{
policy.ChangeTemplate(template),
},
@@ -6,14 +6,14 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddDefaultPasswordAgePolicy(ctx context.Context, policy *domain.PasswordAgePolicy) (*domain.PasswordAgePolicy, error) {
addedPolicy := NewIAMPasswordAgePolicyWriteModel()
iamAgg := IAMAggregateFromWriteModel(&addedPolicy.WriteModel)
event, err := c.addDefaultPasswordAgePolicy(ctx, iamAgg, addedPolicy, policy)
addedPolicy := NewInstancePasswordAgePolicyWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&addedPolicy.WriteModel)
event, err := c.addDefaultPasswordAgePolicy(ctx, instanceAgg, addedPolicy, policy)
if err != nil {
return nil, err
}
@@ -29,16 +29,16 @@ func (c *Commands) AddDefaultPasswordAgePolicy(ctx context.Context, policy *doma
return writeModelToPasswordAgePolicy(&addedPolicy.PasswordAgePolicyWriteModel), nil
}
func (c *Commands) addDefaultPasswordAgePolicy(ctx context.Context, iamAgg *eventstore.Aggregate, addedPolicy *IAMPasswordAgePolicyWriteModel, policy *domain.PasswordAgePolicy) (eventstore.Command, error) {
func (c *Commands) addDefaultPasswordAgePolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, addedPolicy *InstancePasswordAgePolicyWriteModel, policy *domain.PasswordAgePolicy) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, addedPolicy)
if err != nil {
return nil, err
}
if addedPolicy.State == domain.PolicyStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-Lk0dS", "Errors.IAM.PasswordAgePolicy.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-Lk0dS", "Errors.IAM.PasswordAgePolicy.AlreadyExists")
}
return iam_repo.NewPasswordAgePolicyAddedEvent(ctx, iamAgg, policy.ExpireWarnDays, policy.MaxAgeDays), nil
return instance.NewPasswordAgePolicyAddedEvent(ctx, instanceAgg, policy.ExpireWarnDays, policy.MaxAgeDays), nil
}
@@ -48,13 +48,13 @@ func (c *Commands) ChangeDefaultPasswordAgePolicy(ctx context.Context, policy *d
return nil, err
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-0oPew", "Errors.IAM.PasswordAgePolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-0oPew", "Errors.IAM.PasswordAgePolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.PasswordAgePolicyWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, iamAgg, policy.ExpireWarnDays, policy.MaxAgeDays)
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.PasswordAgePolicyWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, instanceAgg, policy.ExpireWarnDays, policy.MaxAgeDays)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
}
pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
@@ -69,11 +69,11 @@ func (c *Commands) ChangeDefaultPasswordAgePolicy(ctx context.Context, policy *d
return writeModelToPasswordAgePolicy(&existingPolicy.PasswordAgePolicyWriteModel), nil
}
func (c *Commands) defaultPasswordAgePolicyWriteModelByID(ctx context.Context) (policy *IAMPasswordAgePolicyWriteModel, err error) {
func (c *Commands) defaultPasswordAgePolicyWriteModelByID(ctx context.Context) (policy *InstancePasswordAgePolicyWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMPasswordAgePolicyWriteModel()
writeModel := NewInstancePasswordAgePolicyWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -7,7 +7,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
"github.com/stretchr/testify/assert"
"testing"
@@ -38,8 +38,8 @@ func TestCommandSide_AddDefaultPasswordAgePolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewPasswordAgePolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPasswordAgePolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
365,
10,
),
@@ -67,8 +67,8 @@ func TestCommandSide_AddDefaultPasswordAgePolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewPasswordAgePolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPasswordAgePolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
365,
10,
),
@@ -159,8 +159,8 @@ func TestCommandSide_ChangeDefaultPasswordAgePolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewPasswordAgePolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPasswordAgePolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
365,
10,
),
@@ -186,8 +186,8 @@ func TestCommandSide_ChangeDefaultPasswordAgePolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewPasswordAgePolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPasswordAgePolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
365,
10,
),
@@ -240,9 +240,9 @@ func TestCommandSide_ChangeDefaultPasswordAgePolicy(t *testing.T) {
}
}
func newDefaultPasswordAgePolicyChangedEvent(ctx context.Context, maxAgeDays, expiryWarnDays uint64) *iam.PasswordAgePolicyChangedEvent {
event, _ := iam.NewPasswordAgePolicyChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultPasswordAgePolicyChangedEvent(ctx context.Context, maxAgeDays, expiryWarnDays uint64) *instance.PasswordAgePolicyChangedEvent {
event, _ := instance.NewPasswordAgePolicyChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
[]policy.PasswordAgePolicyChanges{
policy.ChangeExpireWarnDays(expiryWarnDays),
policy.ChangeMaxAgeDays(maxAgeDays),
@@ -6,18 +6,18 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) getDefaultPasswordComplexityPolicy(ctx context.Context) (*domain.PasswordComplexityPolicy, error) {
policyWriteModel := NewIAMPasswordComplexityPolicyWriteModel()
policyWriteModel := NewInstancePasswordComplexityPolicyWriteModel()
err := c.eventstore.FilterToQueryReducer(ctx, policyWriteModel)
if err != nil {
return nil, err
}
if !policyWriteModel.State.Exists() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-M0gsf", "Errors.IAM.OrgIAMPolicy.NotFound")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-M0gsf", "Errors.IAM.PasswordComplexityPolicy.NotFound")
}
policy := writeModelToPasswordComplexityPolicy(&policyWriteModel.PasswordComplexityPolicyWriteModel)
policy.Default = true
@@ -25,9 +25,9 @@ func (c *Commands) getDefaultPasswordComplexityPolicy(ctx context.Context) (*dom
}
func (c *Commands) AddDefaultPasswordComplexityPolicy(ctx context.Context, policy *domain.PasswordComplexityPolicy) (*domain.PasswordComplexityPolicy, error) {
addedPolicy := NewIAMPasswordComplexityPolicyWriteModel()
iamAgg := IAMAggregateFromWriteModel(&addedPolicy.WriteModel)
events, err := c.addDefaultPasswordComplexityPolicy(ctx, iamAgg, addedPolicy, policy)
addedPolicy := NewInstancePasswordComplexityPolicyWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&addedPolicy.WriteModel)
events, err := c.addDefaultPasswordComplexityPolicy(ctx, instanceAgg, addedPolicy, policy)
if err != nil {
return nil, err
}
@@ -43,7 +43,7 @@ func (c *Commands) AddDefaultPasswordComplexityPolicy(ctx context.Context, polic
return writeModelToPasswordComplexityPolicy(&addedPolicy.PasswordComplexityPolicyWriteModel), nil
}
func (c *Commands) addDefaultPasswordComplexityPolicy(ctx context.Context, iamAgg *eventstore.Aggregate, addedPolicy *IAMPasswordComplexityPolicyWriteModel, policy *domain.PasswordComplexityPolicy) (eventstore.Command, error) {
func (c *Commands) addDefaultPasswordComplexityPolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, addedPolicy *InstancePasswordComplexityPolicyWriteModel, policy *domain.PasswordComplexityPolicy) (eventstore.Command, error) {
if err := policy.IsValid(); err != nil {
return nil, err
}
@@ -53,10 +53,10 @@ func (c *Commands) addDefaultPasswordComplexityPolicy(ctx context.Context, iamAg
return nil, err
}
if addedPolicy.State == domain.PolicyStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-Lk0dS", "Errors.IAM.PasswordComplexityPolicy.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-Lk0dS", "Errors.IAM.PasswordComplexityPolicy.AlreadyExists")
}
return iam_repo.NewPasswordComplexityPolicyAddedEvent(ctx, iamAgg, policy.MinLength, policy.HasLowercase, policy.HasUppercase, policy.HasNumber, policy.HasSymbol), nil
return instance.NewPasswordComplexityPolicyAddedEvent(ctx, instanceAgg, policy.MinLength, policy.HasLowercase, policy.HasUppercase, policy.HasNumber, policy.HasSymbol), nil
}
func (c *Commands) ChangeDefaultPasswordComplexityPolicy(ctx context.Context, policy *domain.PasswordComplexityPolicy) (*domain.PasswordComplexityPolicy, error) {
@@ -69,13 +69,13 @@ func (c *Commands) ChangeDefaultPasswordComplexityPolicy(ctx context.Context, po
return nil, err
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-0oPew", "Errors.IAM.PasswordAgePolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-0oPew", "Errors.IAM.PasswordAgePolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.PasswordComplexityPolicyWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, iamAgg, policy.MinLength, policy.HasLowercase, policy.HasUppercase, policy.HasNumber, policy.HasSymbol)
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.PasswordComplexityPolicyWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, instanceAgg, policy.MinLength, policy.HasLowercase, policy.HasUppercase, policy.HasNumber, policy.HasSymbol)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
}
pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
if err != nil {
@@ -88,11 +88,11 @@ func (c *Commands) ChangeDefaultPasswordComplexityPolicy(ctx context.Context, po
return writeModelToPasswordComplexityPolicy(&existingPolicy.PasswordComplexityPolicyWriteModel), nil
}
func (c *Commands) defaultPasswordComplexityPolicyWriteModelByID(ctx context.Context) (policy *IAMPasswordComplexityPolicyWriteModel, err error) {
func (c *Commands) defaultPasswordComplexityPolicyWriteModelByID(ctx context.Context) (policy *InstancePasswordComplexityPolicyWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMPasswordComplexityPolicyWriteModel()
writeModel := NewInstancePasswordComplexityPolicyWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -6,16 +6,16 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMPasswordComplexityPolicyWriteModel struct {
type InstancePasswordComplexityPolicyWriteModel struct {
PasswordComplexityPolicyWriteModel
}
func NewIAMPasswordComplexityPolicyWriteModel() *IAMPasswordComplexityPolicyWriteModel {
return &IAMPasswordComplexityPolicyWriteModel{
func NewInstancePasswordComplexityPolicyWriteModel() *InstancePasswordComplexityPolicyWriteModel {
return &InstancePasswordComplexityPolicyWriteModel{
PasswordComplexityPolicyWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -25,34 +25,34 @@ func NewIAMPasswordComplexityPolicyWriteModel() *IAMPasswordComplexityPolicyWrit
}
}
func (wm *IAMPasswordComplexityPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstancePasswordComplexityPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.PasswordComplexityPolicyAddedEvent:
case *instance.PasswordComplexityPolicyAddedEvent:
wm.PasswordComplexityPolicyWriteModel.AppendEvents(&e.PasswordComplexityPolicyAddedEvent)
case *iam.PasswordComplexityPolicyChangedEvent:
case *instance.PasswordComplexityPolicyChangedEvent:
wm.PasswordComplexityPolicyWriteModel.AppendEvents(&e.PasswordComplexityPolicyChangedEvent)
}
}
}
func (wm *IAMPasswordComplexityPolicyWriteModel) Reduce() error {
func (wm *InstancePasswordComplexityPolicyWriteModel) Reduce() error {
return wm.PasswordComplexityPolicyWriteModel.Reduce()
}
func (wm *IAMPasswordComplexityPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstancePasswordComplexityPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.PasswordComplexityPolicyWriteModel.AggregateID).
EventTypes(
iam.PasswordComplexityPolicyAddedEventType,
iam.PasswordComplexityPolicyChangedEventType).
instance.PasswordComplexityPolicyAddedEventType,
instance.PasswordComplexityPolicyChangedEventType).
Builder()
}
func (wm *IAMPasswordComplexityPolicyWriteModel) NewChangedEvent(
func (wm *InstancePasswordComplexityPolicyWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
minLength uint64,
@@ -60,7 +60,7 @@ func (wm *IAMPasswordComplexityPolicyWriteModel) NewChangedEvent(
hasUppercase,
hasNumber,
hasSymbol bool,
) (*iam.PasswordComplexityPolicyChangedEvent, bool) {
) (*instance.PasswordComplexityPolicyChangedEvent, bool) {
changes := make([]policy.PasswordComplexityPolicyChanges, 0)
if wm.MinLength != minLength {
@@ -81,7 +81,7 @@ func (wm *IAMPasswordComplexityPolicyWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewPasswordComplexityPolicyChangedEvent(ctx, aggregate, changes)
changedEvent, err := instance.NewPasswordComplexityPolicyChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
@@ -7,7 +7,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
"github.com/stretchr/testify/assert"
"testing"
@@ -59,8 +59,8 @@ func TestCommandSide_AddDefaultPasswordComplexityPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPasswordComplexityPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
8,
true, true, true, true,
),
@@ -91,8 +91,8 @@ func TestCommandSide_AddDefaultPasswordComplexityPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPasswordComplexityPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
8,
true, true, true, true,
),
@@ -213,8 +213,8 @@ func TestCommandSide_ChangeDefaultPasswordComplexityPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPasswordComplexityPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
8,
true, true, true, true,
),
@@ -243,8 +243,8 @@ func TestCommandSide_ChangeDefaultPasswordComplexityPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPasswordComplexityPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
8,
true, true, true, true,
),
@@ -303,9 +303,9 @@ func TestCommandSide_ChangeDefaultPasswordComplexityPolicy(t *testing.T) {
}
}
func newDefaultPasswordComplexityPolicyChangedEvent(ctx context.Context, minLength uint64, hasUpper, hasLower, hasNumber, hasSymbol bool) *iam.PasswordComplexityPolicyChangedEvent {
event, _ := iam.NewPasswordComplexityPolicyChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultPasswordComplexityPolicyChangedEvent(ctx context.Context, minLength uint64, hasUpper, hasLower, hasNumber, hasSymbol bool) *instance.PasswordComplexityPolicyChangedEvent {
event, _ := instance.NewPasswordComplexityPolicyChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
[]policy.PasswordComplexityPolicyChanges{
policy.ChangeMinLength(minLength),
policy.ChangeHasUppercase(hasUpper),
@@ -6,14 +6,14 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddDefaultLockoutPolicy(ctx context.Context, policy *domain.LockoutPolicy) (*domain.LockoutPolicy, error) {
addedPolicy := NewIAMLockoutPolicyWriteModel()
iamAgg := IAMAggregateFromWriteModel(&addedPolicy.WriteModel)
event, err := c.addDefaultLockoutPolicy(ctx, iamAgg, addedPolicy, policy)
addedPolicy := NewInstanceLockoutPolicyWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&addedPolicy.WriteModel)
event, err := c.addDefaultLockoutPolicy(ctx, instanceAgg, addedPolicy, policy)
if err != nil {
return nil, err
}
@@ -29,16 +29,16 @@ func (c *Commands) AddDefaultLockoutPolicy(ctx context.Context, policy *domain.L
return writeModelToLockoutPolicy(&addedPolicy.LockoutPolicyWriteModel), nil
}
func (c *Commands) addDefaultLockoutPolicy(ctx context.Context, iamAgg *eventstore.Aggregate, addedPolicy *IAMLockoutPolicyWriteModel, policy *domain.LockoutPolicy) (eventstore.Command, error) {
func (c *Commands) addDefaultLockoutPolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, addedPolicy *InstanceLockoutPolicyWriteModel, policy *domain.LockoutPolicy) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, addedPolicy)
if err != nil {
return nil, err
}
if addedPolicy.State == domain.PolicyStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-0olDf", "Errors.IAM.LockoutPolicy.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-0olDf", "Errors.IAM.LockoutPolicy.AlreadyExists")
}
return iam_repo.NewLockoutPolicyAddedEvent(ctx, iamAgg, policy.MaxPasswordAttempts, policy.ShowLockOutFailures), nil
return instance.NewLockoutPolicyAddedEvent(ctx, instanceAgg, policy.MaxPasswordAttempts, policy.ShowLockOutFailures), nil
}
func (c *Commands) ChangeDefaultLockoutPolicy(ctx context.Context, policy *domain.LockoutPolicy) (*domain.LockoutPolicy, error) {
@@ -47,13 +47,13 @@ func (c *Commands) ChangeDefaultLockoutPolicy(ctx context.Context, policy *domai
return nil, err
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-0oPew", "Errors.IAM.LockoutPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-0oPew", "Errors.IAM.LockoutPolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.LockoutPolicyWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, iamAgg, policy.MaxPasswordAttempts, policy.ShowLockOutFailures)
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.LockoutPolicyWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, instanceAgg, policy.MaxPasswordAttempts, policy.ShowLockOutFailures)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-4M9vs", "Errors.IAM.LockoutPolicy.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-4M9vs", "Errors.IAM.LockoutPolicy.NotChanged")
}
pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
@@ -67,11 +67,11 @@ func (c *Commands) ChangeDefaultLockoutPolicy(ctx context.Context, policy *domai
return writeModelToLockoutPolicy(&existingPolicy.LockoutPolicyWriteModel), nil
}
func (c *Commands) defaultLockoutPolicyWriteModelByID(ctx context.Context) (policy *IAMLockoutPolicyWriteModel, err error) {
func (c *Commands) defaultLockoutPolicyWriteModelByID(ctx context.Context) (policy *InstanceLockoutPolicyWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMLockoutPolicyWriteModel()
writeModel := NewInstanceLockoutPolicyWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -6,16 +6,16 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMLockoutPolicyWriteModel struct {
type InstanceLockoutPolicyWriteModel struct {
LockoutPolicyWriteModel
}
func NewIAMLockoutPolicyWriteModel() *IAMLockoutPolicyWriteModel {
return &IAMLockoutPolicyWriteModel{
func NewInstanceLockoutPolicyWriteModel() *InstanceLockoutPolicyWriteModel {
return &InstanceLockoutPolicyWriteModel{
LockoutPolicyWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -25,38 +25,38 @@ func NewIAMLockoutPolicyWriteModel() *IAMLockoutPolicyWriteModel {
}
}
func (wm *IAMLockoutPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstanceLockoutPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.LockoutPolicyAddedEvent:
case *instance.LockoutPolicyAddedEvent:
wm.LockoutPolicyWriteModel.AppendEvents(&e.LockoutPolicyAddedEvent)
case *iam.LockoutPolicyChangedEvent:
case *instance.LockoutPolicyChangedEvent:
wm.LockoutPolicyWriteModel.AppendEvents(&e.LockoutPolicyChangedEvent)
}
}
}
func (wm *IAMLockoutPolicyWriteModel) Reduce() error {
func (wm *InstanceLockoutPolicyWriteModel) Reduce() error {
return wm.LockoutPolicyWriteModel.Reduce()
}
func (wm *IAMLockoutPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceLockoutPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.LockoutPolicyWriteModel.AggregateID).
EventTypes(
iam.LockoutPolicyAddedEventType,
iam.LockoutPolicyChangedEventType).
instance.LockoutPolicyAddedEventType,
instance.LockoutPolicyChangedEventType).
Builder()
}
func (wm *IAMLockoutPolicyWriteModel) NewChangedEvent(
func (wm *InstanceLockoutPolicyWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
maxAttempts uint64,
showLockoutFailure bool) (*iam.LockoutPolicyChangedEvent, bool) {
showLockoutFailure bool) (*instance.LockoutPolicyChangedEvent, bool) {
changes := make([]policy.LockoutPolicyChanges, 0)
if wm.MaxPasswordAttempts != maxAttempts {
changes = append(changes, policy.ChangeMaxAttempts(maxAttempts))
@@ -67,7 +67,7 @@ func (wm *IAMLockoutPolicyWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewLockoutPolicyChangedEvent(ctx, aggregate, changes)
changedEvent, err := instance.NewLockoutPolicyChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
@@ -2,15 +2,16 @@ package command
import (
"context"
"testing"
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
"github.com/stretchr/testify/assert"
"testing"
)
func TestCommandSide_AddDefaultLockoutPolicy(t *testing.T) {
@@ -38,8 +39,8 @@ func TestCommandSide_AddDefaultLockoutPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLockoutPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLockoutPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
10,
true,
),
@@ -67,8 +68,8 @@ func TestCommandSide_AddDefaultLockoutPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewLockoutPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLockoutPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
10,
true,
),
@@ -159,8 +160,8 @@ func TestCommandSide_ChangeDefaultLockoutPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLockoutPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLockoutPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
10,
true,
),
@@ -186,8 +187,8 @@ func TestCommandSide_ChangeDefaultLockoutPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewLockoutPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLockoutPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
10,
true,
),
@@ -240,9 +241,9 @@ func TestCommandSide_ChangeDefaultLockoutPolicy(t *testing.T) {
}
}
func newDefaultLockoutPolicyChangedEvent(ctx context.Context, maxAttempts uint64, showLockoutFailure bool) *iam.LockoutPolicyChangedEvent {
event, _ := iam.NewLockoutPolicyChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultLockoutPolicyChangedEvent(ctx context.Context, maxAttempts uint64, showLockoutFailure bool) *instance.LockoutPolicyChangedEvent {
event, _ := instance.NewLockoutPolicyChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
[]policy.LockoutPolicyChanges{
policy.ChangeMaxAttempts(maxAttempts),
policy.ChangeShowLockOutFailures(showLockoutFailure),
@@ -6,18 +6,18 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) getDefaultPrivacyPolicy(ctx context.Context) (*domain.PrivacyPolicy, error) {
policyWriteModel := NewIAMPrivacyPolicyWriteModel()
policyWriteModel := NewInstancePrivacyPolicyWriteModel()
err := c.eventstore.FilterToQueryReducer(ctx, policyWriteModel)
if err != nil {
return nil, err
}
if !policyWriteModel.State.Exists() {
return nil, caos_errs.ThrowInvalidArgument(nil, "IAM-559os", "Errors.IAM.OrgIAMPolicy.NotFound")
return nil, caos_errs.ThrowInvalidArgument(nil, "INSTANCE-559os", "Errors.IAM.PasswordAgePolicy.NotFound")
}
policy := writeModelToPrivacyPolicy(&policyWriteModel.PrivacyPolicyWriteModel)
policy.Default = true
@@ -25,9 +25,9 @@ func (c *Commands) getDefaultPrivacyPolicy(ctx context.Context) (*domain.Privacy
}
func (c *Commands) AddDefaultPrivacyPolicy(ctx context.Context, policy *domain.PrivacyPolicy) (*domain.PrivacyPolicy, error) {
addedPolicy := NewIAMPrivacyPolicyWriteModel()
iamAgg := IAMAggregateFromWriteModel(&addedPolicy.WriteModel)
events, err := c.addDefaultPrivacyPolicy(ctx, iamAgg, addedPolicy, policy)
addedPolicy := NewInstancePrivacyPolicyWriteModel()
instanceAgg := InstanceAggregateFromWriteModel(&addedPolicy.WriteModel)
events, err := c.addDefaultPrivacyPolicy(ctx, instanceAgg, addedPolicy, policy)
if err != nil {
return nil, err
}
@@ -43,16 +43,16 @@ func (c *Commands) AddDefaultPrivacyPolicy(ctx context.Context, policy *domain.P
return writeModelToPrivacyPolicy(&addedPolicy.PrivacyPolicyWriteModel), nil
}
func (c *Commands) addDefaultPrivacyPolicy(ctx context.Context, iamAgg *eventstore.Aggregate, addedPolicy *IAMPrivacyPolicyWriteModel, policy *domain.PrivacyPolicy) (eventstore.Command, error) {
func (c *Commands) addDefaultPrivacyPolicy(ctx context.Context, instanceAgg *eventstore.Aggregate, addedPolicy *InstancePrivacyPolicyWriteModel, policy *domain.PrivacyPolicy) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, addedPolicy)
if err != nil {
return nil, err
}
if addedPolicy.State == domain.PolicyStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "IAM-M00rJ", "Errors.IAM.PrivacyPolicy.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "INSTANCE-M00rJ", "Errors.IAM.PrivacyPolicy.AlreadyExists")
}
return iam_repo.NewPrivacyPolicyAddedEvent(ctx, iamAgg, policy.TOSLink, policy.PrivacyLink, policy.HelpLink), nil
return instance.NewPrivacyPolicyAddedEvent(ctx, instanceAgg, policy.TOSLink, policy.PrivacyLink, policy.HelpLink), nil
}
func (c *Commands) ChangeDefaultPrivacyPolicy(ctx context.Context, policy *domain.PrivacyPolicy) (*domain.PrivacyPolicy, error) {
@@ -61,13 +61,13 @@ func (c *Commands) ChangeDefaultPrivacyPolicy(ctx context.Context, policy *domai
return nil, err
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "IAM-0oPew", "Errors.IAM.PasswordAgePolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "INSTANCE-0oPew", "Errors.IAM.PasswordAgePolicy.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&existingPolicy.PrivacyPolicyWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, iamAgg, policy.TOSLink, policy.PrivacyLink, policy.HelpLink)
instanceAgg := InstanceAggregateFromWriteModel(&existingPolicy.PrivacyPolicyWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, instanceAgg, policy.TOSLink, policy.PrivacyLink, policy.HelpLink)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "IAM-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
return nil, caos_errs.ThrowPreconditionFailed(nil, "INSTANCE-4M9vs", "Errors.IAM.LabelPolicy.NotChanged")
}
pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
if err != nil {
@@ -80,11 +80,11 @@ func (c *Commands) ChangeDefaultPrivacyPolicy(ctx context.Context, policy *domai
return writeModelToPrivacyPolicy(&existingPolicy.PrivacyPolicyWriteModel), nil
}
func (c *Commands) defaultPrivacyPolicyWriteModelByID(ctx context.Context) (policy *IAMPrivacyPolicyWriteModel, err error) {
func (c *Commands) defaultPrivacyPolicyWriteModelByID(ctx context.Context) (policy *InstancePrivacyPolicyWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewIAMPrivacyPolicyWriteModel()
writeModel := NewInstancePrivacyPolicyWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -3,19 +3,18 @@ package command
import (
"context"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMPrivacyPolicyWriteModel struct {
type InstancePrivacyPolicyWriteModel struct {
PrivacyPolicyWriteModel
}
func NewIAMPrivacyPolicyWriteModel() *IAMPrivacyPolicyWriteModel {
return &IAMPrivacyPolicyWriteModel{
func NewInstancePrivacyPolicyWriteModel() *InstancePrivacyPolicyWriteModel {
return &InstancePrivacyPolicyWriteModel{
PrivacyPolicyWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
@@ -25,40 +24,40 @@ func NewIAMPrivacyPolicyWriteModel() *IAMPrivacyPolicyWriteModel {
}
}
func (wm *IAMPrivacyPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
func (wm *InstancePrivacyPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.PrivacyPolicyAddedEvent:
case *instance.PrivacyPolicyAddedEvent:
wm.PrivacyPolicyWriteModel.AppendEvents(&e.PrivacyPolicyAddedEvent)
case *iam.PrivacyPolicyChangedEvent:
case *instance.PrivacyPolicyChangedEvent:
wm.PrivacyPolicyWriteModel.AppendEvents(&e.PrivacyPolicyChangedEvent)
}
}
}
func (wm *IAMPrivacyPolicyWriteModel) Reduce() error {
func (wm *InstancePrivacyPolicyWriteModel) Reduce() error {
return wm.PrivacyPolicyWriteModel.Reduce()
}
func (wm *IAMPrivacyPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstancePrivacyPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.PrivacyPolicyWriteModel.AggregateID).
EventTypes(
iam.PrivacyPolicyAddedEventType,
iam.PrivacyPolicyChangedEventType).
instance.PrivacyPolicyAddedEventType,
instance.PrivacyPolicyChangedEventType).
Builder()
}
func (wm *IAMPrivacyPolicyWriteModel) NewChangedEvent(
func (wm *InstancePrivacyPolicyWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
tosLink,
privacyLink,
helpLink string,
) (*iam.PrivacyPolicyChangedEvent, bool) {
) (*instance.PrivacyPolicyChangedEvent, bool) {
changes := make([]policy.PrivacyPolicyChanges, 0)
if wm.TOSLink != tosLink {
@@ -73,7 +72,7 @@ func (wm *IAMPrivacyPolicyWriteModel) NewChangedEvent(
if len(changes) == 0 {
return nil, false
}
changedEvent, err := iam.NewPrivacyPolicyChangedEvent(ctx, aggregate, changes)
changedEvent, err := instance.NewPrivacyPolicyChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
@@ -11,7 +11,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/policy"
)
@@ -40,8 +40,8 @@ func TestCommandSide_AddDefaultPrivacyPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPrivacyPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"TOSLink",
"PrivacyLink",
"HelpLink",
@@ -71,8 +71,8 @@ func TestCommandSide_AddDefaultPrivacyPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPrivacyPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"TOSLink",
"PrivacyLink",
"HelpLink",
@@ -111,8 +111,8 @@ func TestCommandSide_AddDefaultPrivacyPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPrivacyPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"",
"",
"",
@@ -207,8 +207,8 @@ func TestCommandSide_ChangeDefaultPrivacyPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPrivacyPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"TOSLink",
"PrivacyLink",
"HelpLink",
@@ -236,8 +236,8 @@ func TestCommandSide_ChangeDefaultPrivacyPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewPrivacyPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"TOSLink",
"PrivacyLink",
"HelpLink",
@@ -297,9 +297,9 @@ func TestCommandSide_ChangeDefaultPrivacyPolicy(t *testing.T) {
}
}
func newDefaultPrivacyPolicyChangedEvent(ctx context.Context, tosLink, privacyLink, helpLink string) *iam.PrivacyPolicyChangedEvent {
event, _ := iam.NewPrivacyPolicyChangedEvent(ctx,
&iam.NewAggregate().Aggregate,
func newDefaultPrivacyPolicyChangedEvent(ctx context.Context, tosLink, privacyLink, helpLink string) *instance.PrivacyPolicyChangedEvent {
event, _ := instance.NewPrivacyPolicyChangedEvent(ctx,
&instance.NewAggregate().Aggregate,
[]policy.PrivacyPolicyChanges{
policy.ChangeTOSLink(tosLink),
policy.ChangePrivacyLink(privacyLink),
@@ -6,10 +6,10 @@ import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMSecretGeneratorConfigWriteModel struct {
type InstanceSecretGeneratorConfigWriteModel struct {
eventstore.WriteModel
GeneratorType domain.SecretGeneratorType
@@ -22,8 +22,8 @@ type IAMSecretGeneratorConfigWriteModel struct {
State domain.SecretGeneratorState
}
func NewIAMSecretGeneratorConfigWriteModel(GeneratorType domain.SecretGeneratorType) *IAMSecretGeneratorConfigWriteModel {
return &IAMSecretGeneratorConfigWriteModel{
func NewInstanceSecretGeneratorConfigWriteModel(GeneratorType domain.SecretGeneratorType) *InstanceSecretGeneratorConfigWriteModel {
return &InstanceSecretGeneratorConfigWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
ResourceOwner: domain.IAMID,
@@ -32,10 +32,10 @@ func NewIAMSecretGeneratorConfigWriteModel(GeneratorType domain.SecretGeneratorT
}
}
func (wm *IAMSecretGeneratorConfigWriteModel) Reduce() error {
func (wm *InstanceSecretGeneratorConfigWriteModel) Reduce() error {
for _, event := range wm.Events {
switch e := event.(type) {
case *iam.SecretGeneratorAddedEvent:
case *instance.SecretGeneratorAddedEvent:
if wm.GeneratorType != e.GeneratorType {
continue
}
@@ -46,7 +46,7 @@ func (wm *IAMSecretGeneratorConfigWriteModel) Reduce() error {
wm.IncludeDigits = e.IncludeDigits
wm.IncludeSymbols = e.IncludeDigits
wm.State = domain.SecretGeneratorStateActive
case *iam.SecretGeneratorChangedEvent:
case *instance.SecretGeneratorChangedEvent:
if wm.GeneratorType != e.GeneratorType {
continue
}
@@ -68,7 +68,7 @@ func (wm *IAMSecretGeneratorConfigWriteModel) Reduce() error {
if e.IncludeSymbols != nil {
wm.IncludeSymbols = *e.IncludeSymbols
}
case *iam.SecretGeneratorRemovedEvent:
case *instance.SecretGeneratorRemovedEvent:
if wm.GeneratorType != e.GeneratorType {
continue
}
@@ -84,20 +84,20 @@ func (wm *IAMSecretGeneratorConfigWriteModel) Reduce() error {
return wm.WriteModel.Reduce()
}
func (wm *IAMSecretGeneratorConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceSecretGeneratorConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.AggregateID).
EventTypes(
iam.SecretGeneratorAddedEventType,
iam.SecretGeneratorChangedEventType,
iam.SecretGeneratorRemovedEventType).
instance.SecretGeneratorAddedEventType,
instance.SecretGeneratorChangedEventType,
instance.SecretGeneratorRemovedEventType).
Builder()
}
func (wm *IAMSecretGeneratorConfigWriteModel) NewChangedEvent(
func (wm *InstanceSecretGeneratorConfigWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
generatorType domain.SecretGeneratorType,
@@ -107,32 +107,32 @@ func (wm *IAMSecretGeneratorConfigWriteModel) NewChangedEvent(
includeUpperLetters,
includeDigits,
includeSymbols bool,
) (*iam.SecretGeneratorChangedEvent, bool, error) {
changes := make([]iam.SecretGeneratorChanges, 0)
) (*instance.SecretGeneratorChangedEvent, bool, error) {
changes := make([]instance.SecretGeneratorChanges, 0)
var err error
if wm.Length != length {
changes = append(changes, iam.ChangeSecretGeneratorLength(length))
changes = append(changes, instance.ChangeSecretGeneratorLength(length))
}
if wm.Expiry != expiry {
changes = append(changes, iam.ChangeSecretGeneratorExpiry(expiry))
changes = append(changes, instance.ChangeSecretGeneratorExpiry(expiry))
}
if wm.IncludeLowerLetters != includeLowerLetters {
changes = append(changes, iam.ChangeSecretGeneratorIncludeLowerLetters(includeLowerLetters))
changes = append(changes, instance.ChangeSecretGeneratorIncludeLowerLetters(includeLowerLetters))
}
if wm.IncludeUpperLetters != includeUpperLetters {
changes = append(changes, iam.ChangeSecretGeneratorIncludeUpperLetters(includeUpperLetters))
changes = append(changes, instance.ChangeSecretGeneratorIncludeUpperLetters(includeUpperLetters))
}
if wm.IncludeDigits != includeDigits {
changes = append(changes, iam.ChangeSecretGeneratorIncludeDigits(includeDigits))
changes = append(changes, instance.ChangeSecretGeneratorIncludeDigits(includeDigits))
}
if wm.IncludeSymbols != includeSymbols {
changes = append(changes, iam.ChangeSecretGeneratorIncludeSymbols(includeSymbols))
changes = append(changes, instance.ChangeSecretGeneratorIncludeSymbols(includeSymbols))
}
if len(changes) == 0 {
return nil, false, nil
}
changeEvent, err := iam.NewSecretGeneratorChangeEvent(ctx, aggregate, generatorType, changes)
changeEvent, err := instance.NewSecretGeneratorChangeEvent(ctx, aggregate, generatorType, changes)
if err != nil {
return nil, false, err
}
@@ -6,7 +6,7 @@ import (
"github.com/caos/zitadel/internal/crypto"
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
func (c *Commands) AddSecretGeneratorConfig(ctx context.Context, generatorType domain.SecretGeneratorType, config *crypto.GeneratorConfig) (*domain.ObjectDetails, error) {
@@ -21,10 +21,10 @@ func (c *Commands) AddSecretGeneratorConfig(ctx context.Context, generatorType d
if generatorWriteModel.State == domain.SecretGeneratorStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "COMMAND-3n9ls", "Errors.SecretGenerator.AlreadyExists")
}
iamAgg := IAMAggregateFromWriteModel(&generatorWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam.NewSecretGeneratorAddedEvent(
instanceAgg := InstanceAggregateFromWriteModel(&generatorWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewSecretGeneratorAddedEvent(
ctx,
iamAgg,
instanceAgg,
generatorType,
config.Length,
config.Expiry,
@@ -54,11 +54,11 @@ func (c *Commands) ChangeSecretGeneratorConfig(ctx context.Context, generatorTyp
if generatorWriteModel.State == domain.SecretGeneratorStateUnspecified || generatorWriteModel.State == domain.SecretGeneratorStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "COMMAND-3n9ls", "Errors.SecretGenerator.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&generatorWriteModel.WriteModel)
instanceAgg := InstanceAggregateFromWriteModel(&generatorWriteModel.WriteModel)
changedEvent, hasChanged, err := generatorWriteModel.NewChangedEvent(
ctx,
iamAgg,
instanceAgg,
generatorType,
config.Length,
config.Expiry,
@@ -95,8 +95,8 @@ func (c *Commands) RemoveSecretGeneratorConfig(ctx context.Context, generatorTyp
if generatorWriteModel.State == domain.SecretGeneratorStateUnspecified || generatorWriteModel.State == domain.SecretGeneratorStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "COMMAND-b8les", "Errors.SecretGenerator.NotFound")
}
iamAgg := IAMAggregateFromWriteModel(&generatorWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam.NewSecretGeneratorRemovedEvent(ctx, iamAgg, generatorType))
instanceAgg := InstanceAggregateFromWriteModel(&generatorWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, instance.NewSecretGeneratorRemovedEvent(ctx, instanceAgg, generatorType))
if err != nil {
return nil, err
}
@@ -107,8 +107,8 @@ func (c *Commands) RemoveSecretGeneratorConfig(ctx context.Context, generatorTyp
return writeModelToObjectDetails(&generatorWriteModel.WriteModel), nil
}
func (c *Commands) getSecretConfig(ctx context.Context, generatorType domain.SecretGeneratorType) (_ *IAMSecretGeneratorConfigWriteModel, err error) {
writeModel := NewIAMSecretGeneratorConfigWriteModel(generatorType)
func (c *Commands) getSecretConfig(ctx context.Context, generatorType domain.SecretGeneratorType) (_ *InstanceSecretGeneratorConfigWriteModel, err error) {
writeModel := NewInstanceSecretGeneratorConfigWriteModel(generatorType)
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -12,7 +12,7 @@ import (
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
func TestCommandSide_AddSecretGenerator(t *testing.T) {
@@ -57,8 +57,8 @@ func TestCommandSide_AddSecretGenerator(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewSecretGeneratorAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewSecretGeneratorAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.SecretGeneratorTypeInitCode,
4,
time.Hour*1,
@@ -95,9 +95,9 @@ func TestCommandSide_AddSecretGenerator(t *testing.T) {
expectFilter(),
expectPush(
[]*repository.Event{
eventFromEventPusher(iam.NewSecretGeneratorAddedEvent(
eventFromEventPusher(instance.NewSecretGeneratorAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.SecretGeneratorTypeInitCode,
4,
time.Hour*1,
@@ -108,7 +108,7 @@ func TestCommandSide_AddSecretGenerator(t *testing.T) {
),
),
},
uniqueConstraintsFromEventConstraint(iam.NewAddSecretGeneratorTypeUniqueConstraint(domain.SecretGeneratorTypeInitCode)),
uniqueConstraintsFromEventConstraint(instance.NewAddSecretGeneratorTypeUniqueConstraint(domain.SecretGeneratorTypeInitCode)),
),
),
},
@@ -208,9 +208,9 @@ func TestCommandSide_ChangeSecretGenerator(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewSecretGeneratorAddedEvent(
instance.NewSecretGeneratorAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.SecretGeneratorTypeInitCode,
4,
time.Hour*1,
@@ -221,8 +221,8 @@ func TestCommandSide_ChangeSecretGenerator(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewSecretGeneratorRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewSecretGeneratorRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.SecretGeneratorTypeInitCode),
),
),
@@ -243,9 +243,9 @@ func TestCommandSide_ChangeSecretGenerator(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewSecretGeneratorAddedEvent(
instance.NewSecretGeneratorAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.SecretGeneratorTypeInitCode,
4,
time.Hour*1,
@@ -281,9 +281,9 @@ func TestCommandSide_ChangeSecretGenerator(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewSecretGeneratorAddedEvent(
instance.NewSecretGeneratorAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.SecretGeneratorTypeInitCode,
4,
time.Hour*1,
@@ -404,9 +404,9 @@ func TestCommandSide_RemoveSecretGenerator(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewSecretGeneratorAddedEvent(
instance.NewSecretGeneratorAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.SecretGeneratorTypeInitCode,
4,
time.Hour*1,
@@ -417,8 +417,8 @@ func TestCommandSide_RemoveSecretGenerator(t *testing.T) {
),
),
eventFromEventPusher(
iam.NewSecretGeneratorRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewSecretGeneratorRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.SecretGeneratorTypeInitCode),
),
),
@@ -439,9 +439,9 @@ func TestCommandSide_RemoveSecretGenerator(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewSecretGeneratorAddedEvent(
instance.NewSecretGeneratorAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.SecretGeneratorTypeInitCode,
4,
time.Hour*1,
@@ -455,12 +455,12 @@ func TestCommandSide_RemoveSecretGenerator(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
iam.NewSecretGeneratorRemovedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewSecretGeneratorRemovedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
domain.SecretGeneratorTypeInitCode),
),
},
uniqueConstraintsFromEventConstraint(iam.NewRemoveSecretGeneratorTypeUniqueConstraint(domain.SecretGeneratorTypeInitCode)),
uniqueConstraintsFromEventConstraint(instance.NewRemoveSecretGeneratorTypeUniqueConstraint(domain.SecretGeneratorTypeInitCode)),
),
),
},
@@ -494,17 +494,17 @@ func TestCommandSide_RemoveSecretGenerator(t *testing.T) {
}
}
func newSecretGeneratorChangedEvent(ctx context.Context, generatorType domain.SecretGeneratorType, length uint, expiry time.Duration, lowerCase, upperCase, digits, symbols bool) *iam.SecretGeneratorChangedEvent {
changes := []iam.SecretGeneratorChanges{
iam.ChangeSecretGeneratorLength(length),
iam.ChangeSecretGeneratorExpiry(expiry),
iam.ChangeSecretGeneratorIncludeLowerLetters(lowerCase),
iam.ChangeSecretGeneratorIncludeUpperLetters(upperCase),
iam.ChangeSecretGeneratorIncludeDigits(digits),
iam.ChangeSecretGeneratorIncludeSymbols(symbols),
func newSecretGeneratorChangedEvent(ctx context.Context, generatorType domain.SecretGeneratorType, length uint, expiry time.Duration, lowerCase, upperCase, digits, symbols bool) *instance.SecretGeneratorChangedEvent {
changes := []instance.SecretGeneratorChanges{
instance.ChangeSecretGeneratorLength(length),
instance.ChangeSecretGeneratorExpiry(expiry),
instance.ChangeSecretGeneratorIncludeLowerLetters(lowerCase),
instance.ChangeSecretGeneratorIncludeUpperLetters(upperCase),
instance.ChangeSecretGeneratorIncludeDigits(digits),
instance.ChangeSecretGeneratorIncludeSymbols(symbols),
}
event, _ := iam.NewSecretGeneratorChangeEvent(ctx,
&iam.NewAggregate().Aggregate,
event, _ := instance.NewSecretGeneratorChangeEvent(ctx,
&instance.NewAggregate().Aggregate,
generatorType,
changes,
)
@@ -6,10 +6,10 @@ import (
"github.com/caos/zitadel/internal/crypto"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
)
type IAMSMTPConfigWriteModel struct {
type InstanceSMTPConfigWriteModel struct {
eventstore.WriteModel
SenderAddress string
@@ -21,8 +21,8 @@ type IAMSMTPConfigWriteModel struct {
State domain.SMTPConfigState
}
func NewIAMSMTPConfigWriteModel() *IAMSMTPConfigWriteModel {
return &IAMSMTPConfigWriteModel{
func NewInstanceSMTPConfigWriteModel() *InstanceSMTPConfigWriteModel {
return &InstanceSMTPConfigWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: domain.IAMID,
ResourceOwner: domain.IAMID,
@@ -30,10 +30,10 @@ func NewIAMSMTPConfigWriteModel() *IAMSMTPConfigWriteModel {
}
}
func (wm *IAMSMTPConfigWriteModel) Reduce() error {
func (wm *InstanceSMTPConfigWriteModel) Reduce() error {
for _, event := range wm.Events {
switch e := event.(type) {
case *iam.SMTPConfigAddedEvent:
case *instance.SMTPConfigAddedEvent:
wm.TLS = e.TLS
wm.SenderAddress = e.SenderAddress
wm.SenderName = e.SenderName
@@ -41,7 +41,7 @@ func (wm *IAMSMTPConfigWriteModel) Reduce() error {
wm.User = e.User
wm.Password = e.Password
wm.State = domain.SMTPConfigStateActive
case *iam.SMTPConfigChangedEvent:
case *instance.SMTPConfigChangedEvent:
if e.TLS != nil {
wm.TLS = *e.TLS
}
@@ -62,43 +62,43 @@ func (wm *IAMSMTPConfigWriteModel) Reduce() error {
return wm.WriteModel.Reduce()
}
func (wm *IAMSMTPConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
func (wm *InstanceSMTPConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(wm.AggregateID).
EventTypes(
iam.SMTPConfigAddedEventType,
iam.SMTPConfigChangedEventType,
iam.SMTPConfigPasswordChangedEventType).
instance.SMTPConfigAddedEventType,
instance.SMTPConfigChangedEventType,
instance.SMTPConfigPasswordChangedEventType).
Builder()
}
func (wm *IAMSMTPConfigWriteModel) NewChangedEvent(ctx context.Context, aggregate *eventstore.Aggregate, tls bool, fromAddress, fromName, smtpHost, smtpUser string) (*iam.SMTPConfigChangedEvent, bool, error) {
changes := make([]iam.SMTPConfigChanges, 0)
func (wm *InstanceSMTPConfigWriteModel) NewChangedEvent(ctx context.Context, aggregate *eventstore.Aggregate, tls bool, fromAddress, fromName, smtpHost, smtpUser string) (*instance.SMTPConfigChangedEvent, bool, error) {
changes := make([]instance.SMTPConfigChanges, 0)
var err error
if wm.TLS != tls {
changes = append(changes, iam.ChangeSMTPConfigTLS(tls))
changes = append(changes, instance.ChangeSMTPConfigTLS(tls))
}
if wm.SenderAddress != fromAddress {
changes = append(changes, iam.ChangeSMTPConfigFromAddress(fromAddress))
changes = append(changes, instance.ChangeSMTPConfigFromAddress(fromAddress))
}
if wm.SenderName != fromName {
changes = append(changes, iam.ChangeSMTPConfigFromName(fromName))
changes = append(changes, instance.ChangeSMTPConfigFromName(fromName))
}
if wm.Host != smtpHost {
changes = append(changes, iam.ChangeSMTPConfigSMTPHost(smtpHost))
changes = append(changes, instance.ChangeSMTPConfigSMTPHost(smtpHost))
}
if wm.User != smtpUser {
changes = append(changes, iam.ChangeSMTPConfigSMTPUser(smtpUser))
changes = append(changes, instance.ChangeSMTPConfigSMTPUser(smtpUser))
}
if len(changes) == 0 {
return nil, false, nil
}
changeEvent, err := iam.NewSMTPConfigChangeEvent(ctx, aggregate, changes)
changeEvent, err := instance.NewSMTPConfigChangeEvent(ctx, aggregate, changes)
if err != nil {
return nil, false, err
}
+1 -1
View File
@@ -15,7 +15,7 @@ import (
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/repository/mock"
action_repo "github.com/caos/zitadel/internal/repository/action"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
iam_repo "github.com/caos/zitadel/internal/repository/instance"
key_repo "github.com/caos/zitadel/internal/repository/keypair"
"github.com/caos/zitadel/internal/repository/org"
proj_repo "github.com/caos/zitadel/internal/repository/project"
+3 -3
View File
@@ -33,9 +33,9 @@ func (c *Commands) checkOrgExists(ctx context.Context, orgID string) error {
}
func (c *Commands) SetUpOrg(ctx context.Context, organisation *domain.Org, admin *domain.Human, initCodeGenerator crypto.Generator, phoneCodeGenerator crypto.Generator, claimedUserIDs []string, selfregistered bool) (*domain.ObjectDetails, error) {
orgIAMPolicy, err := c.getDefaultOrgIAMPolicy(ctx)
orgIAMPolicy, err := c.getDefaultDomainPolicy(ctx)
if err != nil {
return nil, caos_errs.ThrowPreconditionFailed(err, "COMMAND-33M9f", "Errors.IAM.OrgIAMPolicy.NotFound")
return nil, caos_errs.ThrowPreconditionFailed(err, "COMMAND-33M9f", "Errors.IAM.DomainPolicy.NotFound")
}
pwPolicy, err := c.getDefaultPasswordComplexityPolicy(ctx)
if err != nil {
@@ -167,7 +167,7 @@ func (c *Commands) setUpOrg(
ctx context.Context,
organisation *domain.Org,
admin *domain.Human,
loginPolicy *domain.OrgIAMPolicy,
loginPolicy *domain.DomainPolicy,
pwPolicy *domain.PasswordComplexityPolicy,
initCodeGenerator crypto.Generator,
phoneCodeGenerator crypto.Generator,
+3 -3
View File
@@ -13,9 +13,9 @@ func orgWriteModelToOrg(wm *OrgWriteModel) *domain.Org {
}
}
func orgWriteModelToOrgIAMPolicy(wm *ORGOrgIAMPolicyWriteModel) *domain.OrgIAMPolicy {
return &domain.OrgIAMPolicy{
ObjectRoot: writeModelToObjectRoot(wm.PolicyOrgIAMWriteModel.WriteModel),
func orgWriteModelToDomainPolicy(wm *OrgDomainPolicyWriteModel) *domain.DomainPolicy {
return &domain.DomainPolicy{
ObjectRoot: writeModelToObjectRoot(wm.PolicyDomainWriteModel.WriteModel),
UserLoginMustBeDomain: wm.UserLoginMustBeDomain,
}
}
+1 -1
View File
@@ -819,7 +819,7 @@ func TestCommandSide_ValidateOrgDomain(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
org.NewOrgIAMPolicyAddedEvent(context.Background(),
org.NewOrgDomainPolicyAddedEvent(context.Background(),
&org.NewAggregate("org2", "org2").Aggregate,
false))),
expectPush(
+1 -1
View File
@@ -384,7 +384,7 @@ func (c *Commands) getOrgFeaturesOrDefault(ctx context.Context, orgID string) (*
return writeModelToFeatures(&existingFeatures.FeaturesWriteModel), nil
}
existingIAMFeatures := NewIAMFeaturesWriteModel()
existingIAMFeatures := NewInstanceFeaturesWriteModel()
err = c.eventstore.FilterToQueryReducer(ctx, existingIAMFeatures)
if err != nil {
return nil, err
+104 -104
View File
@@ -17,7 +17,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/repository/features"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/static"
)
@@ -157,9 +157,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
expectFilter(),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(
instance.NewLoginPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
false,
false,
false,
@@ -176,9 +176,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(
instance.NewPasswordComplexityPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
8,
false,
false,
@@ -189,9 +189,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(
instance.NewLabelPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"primary",
"secondary",
"warn",
@@ -238,9 +238,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.InitCodeMessageType,
domain.MessageSubject,
"text",
@@ -250,9 +250,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.LoginCustomText,
domain.LoginKeyExternalRegistrationUserOverviewTitle,
"text",
@@ -262,9 +262,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(
instance.NewPrivacyPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"toslink",
"privacylink",
"helpLink",
@@ -273,9 +273,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLockoutPolicyAddedEvent(
instance.NewLockoutPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
5,
false,
),
@@ -341,9 +341,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
expectFilter(),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(
instance.NewLoginPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
false,
false,
false,
@@ -360,9 +360,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(
instance.NewPasswordComplexityPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
8,
false,
false,
@@ -373,9 +373,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(
instance.NewLabelPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"primary",
"secondary",
"warn",
@@ -443,9 +443,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.InitCodeMessageType,
domain.MessageSubject,
"text",
@@ -455,9 +455,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.LoginCustomText,
domain.LoginKeyExternalRegistrationUserOverviewTitle,
"text",
@@ -467,9 +467,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(
instance.NewPrivacyPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"toslink",
"privacylink",
"helplink",
@@ -478,9 +478,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLockoutPolicyAddedEvent(
instance.NewLockoutPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
5,
false,
),
@@ -551,9 +551,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
expectFilter(),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(
instance.NewLoginPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
false,
false,
false,
@@ -570,9 +570,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(
instance.NewPasswordComplexityPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
8,
false,
false,
@@ -583,9 +583,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(
instance.NewLabelPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"primary",
"secondary",
"warn",
@@ -660,9 +660,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.InitCodeMessageType,
domain.MessageSubject,
"text",
@@ -672,9 +672,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.LoginCustomText,
domain.LoginKeyExternalRegistrationUserOverviewTitle,
"text",
@@ -684,9 +684,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(
instance.NewPrivacyPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"toslink",
"privacylink",
"helplink",
@@ -695,9 +695,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLockoutPolicyAddedEvent(
instance.NewLockoutPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
5,
false,
),
@@ -771,9 +771,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
expectFilter(),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(
instance.NewLoginPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
false,
false,
false,
@@ -790,9 +790,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(
instance.NewPasswordComplexityPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
8,
false,
false,
@@ -803,9 +803,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(
instance.NewLabelPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"primary",
"secondary",
"warn",
@@ -887,9 +887,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.InitCodeMessageType,
domain.MessageSubject,
"text",
@@ -899,9 +899,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.LoginCustomText,
domain.LoginKeyExternalRegistrationUserOverviewTitle,
"text",
@@ -911,9 +911,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(
instance.NewPrivacyPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"toslink",
"privacylink",
"helplink",
@@ -922,9 +922,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLockoutPolicyAddedEvent(
instance.NewLockoutPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
5,
false,
),
@@ -1006,9 +1006,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
//orgLoginPolicyWriteModelByID
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(
instance.NewLoginPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -1025,7 +1025,7 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
eventFromEventPusher(
org.NewLoginPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
false,
false,
false,
@@ -1043,9 +1043,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
//getDefaultLoginPolicy
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(
instance.NewLoginPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
true,
true,
true,
@@ -1064,10 +1064,10 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
//orgLoginPolicyAuthFactorsWriteModel
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicySecondFactorAddedEvent(context.Background(), &iam.NewAggregate().Aggregate, domain.SecondFactorTypeU2F),
instance.NewLoginPolicySecondFactorAddedEvent(context.Background(), &instance.NewAggregate().Aggregate, domain.SecondFactorTypeU2F),
),
eventFromEventPusher(
iam.NewLoginPolicyMultiFactorAddedEvent(context.Background(), &iam.NewAggregate().Aggregate, domain.MultiFactorTypeU2FWithPIN),
instance.NewLoginPolicyMultiFactorAddedEvent(context.Background(), &instance.NewAggregate().Aggregate, domain.MultiFactorTypeU2FWithPIN),
),
eventFromEventPusher(
org.NewLoginPolicySecondFactorAddedEvent(context.Background(), &org.NewAggregate("org1", "org1").Aggregate, domain.SecondFactorTypeOTP),
@@ -1083,9 +1083,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
//orgPasswordComplexityPolicyWriteModelByID
expectFilter(
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(
instance.NewPasswordComplexityPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
8,
false,
false,
@@ -1096,7 +1096,7 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
eventFromEventPusher(
org.NewPasswordComplexityPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
7,
false,
false,
@@ -1109,9 +1109,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
//orgLabelPolicyWriteModelByID
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(
instance.NewLabelPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"primary",
"secondary",
"warn",
@@ -1128,7 +1128,7 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
eventFromEventPusher(
org.NewLabelPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"custom",
"secondary",
"warn",
@@ -1181,7 +1181,7 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
eventFromEventPusher(
org.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.InitCodeMessageType,
domain.MessageSubject,
"text",
@@ -1193,7 +1193,7 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
eventFromEventPusher(
org.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.LoginCustomText,
domain.LoginKeyExternalRegistrationUserOverviewTitle,
"text",
@@ -1205,7 +1205,7 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
eventFromEventPusher(
org.NewPrivacyPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"toslink",
"privacylink",
"helplink",
@@ -1316,9 +1316,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
expectFilter(),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(
instance.NewLoginPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
false,
false,
false,
@@ -1335,9 +1335,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(
instance.NewPasswordComplexityPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
8,
false,
false,
@@ -1348,9 +1348,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(
instance.NewLabelPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"primary",
"secondary",
"warn",
@@ -1397,9 +1397,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.InitCodeMessageType,
domain.MessageSubject,
"text",
@@ -1409,9 +1409,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.LoginCustomText,
domain.LoginKeyExternalRegistrationUserOverviewTitle,
"text",
@@ -1421,9 +1421,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(
instance.NewPrivacyPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"toslink",
"privacylink",
"helplink",
@@ -1432,9 +1432,9 @@ func TestCommandSide_SetOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLockoutPolicyAddedEvent(
instance.NewLockoutPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
5,
false,
),
@@ -1581,9 +1581,9 @@ func TestCommandSide_RemoveOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(
instance.NewLoginPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
false,
false,
false,
@@ -1600,9 +1600,9 @@ func TestCommandSide_RemoveOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPasswordComplexityPolicyAddedEvent(
instance.NewPasswordComplexityPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
8,
false,
false,
@@ -1613,9 +1613,9 @@ func TestCommandSide_RemoveOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(
instance.NewLabelPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"primary",
"secondary",
"warn",
@@ -1662,9 +1662,9 @@ func TestCommandSide_RemoveOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.InitCodeMessageType,
domain.MessageSubject,
"text",
@@ -1674,9 +1674,9 @@ func TestCommandSide_RemoveOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewCustomTextSetEvent(
instance.NewCustomTextSetEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
domain.LoginCustomText,
domain.LoginKeyExternalRegistrationUserOverviewTitle,
"text",
@@ -1686,9 +1686,9 @@ func TestCommandSide_RemoveOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewPrivacyPolicyAddedEvent(
instance.NewPrivacyPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
"toslink",
"privacylink",
"helplink",
@@ -1697,9 +1697,9 @@ func TestCommandSide_RemoveOrgFeatures(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLockoutPolicyAddedEvent(
instance.NewLockoutPolicyAddedEvent(
context.Background(),
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
5,
false,
),
@@ -1748,10 +1748,10 @@ func TestCommandSide_RemoveOrgFeatures(t *testing.T) {
}
}
func newIAMFeaturesSetEvent(ctx context.Context, tierName string, state domain.FeaturesState, auditLog time.Duration) *iam.FeaturesSetEvent {
event, _ := iam.NewFeaturesSetEvent(
func newIAMFeaturesSetEvent(ctx context.Context, tierName string, state domain.FeaturesState, auditLog time.Duration) *instance.FeaturesSetEvent {
event, _ := instance.NewFeaturesSetEvent(
ctx,
&iam.NewAggregate().Aggregate,
&instance.NewAggregate().Aggregate,
[]features.FeaturesChanges{
features.ChangeTierName(tierName),
features.ChangeState(state),
@@ -10,13 +10,13 @@ import (
"github.com/caos/zitadel/internal/telemetry/tracing"
)
func (c *Commands) AddOrgIAMPolicy(ctx context.Context, resourceOwner string, policy *domain.OrgIAMPolicy) (*domain.OrgIAMPolicy, error) {
func (c *Commands) AddOrgDomainPolicy(ctx context.Context, resourceOwner string, policy *domain.DomainPolicy) (*domain.DomainPolicy, error) {
if resourceOwner == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "Org-4Jfsf", "Errors.ResourceOwnerMissing")
}
addedPolicy := NewORGOrgIAMPolicyWriteModel(resourceOwner)
orgAgg := OrgAggregateFromWriteModel(&addedPolicy.PolicyOrgIAMWriteModel.WriteModel)
event, err := c.addOrgIAMPolicy(ctx, orgAgg, addedPolicy, policy)
addedPolicy := NewOrgDomainPolicyWriteModel(resourceOwner)
orgAgg := OrgAggregateFromWriteModel(&addedPolicy.PolicyDomainWriteModel.WriteModel)
event, err := c.addOrgDomainPolicy(ctx, orgAgg, addedPolicy, policy)
if err != nil {
return nil, err
}
@@ -28,33 +28,33 @@ func (c *Commands) AddOrgIAMPolicy(ctx context.Context, resourceOwner string, po
if err != nil {
return nil, err
}
return orgWriteModelToOrgIAMPolicy(addedPolicy), nil
return orgWriteModelToDomainPolicy(addedPolicy), nil
}
func (c *Commands) addOrgIAMPolicy(ctx context.Context, orgAgg *eventstore.Aggregate, addedPolicy *ORGOrgIAMPolicyWriteModel, policy *domain.OrgIAMPolicy) (eventstore.Command, error) {
func (c *Commands) addOrgDomainPolicy(ctx context.Context, orgAgg *eventstore.Aggregate, addedPolicy *OrgDomainPolicyWriteModel, policy *domain.DomainPolicy) (eventstore.Command, error) {
err := c.eventstore.FilterToQueryReducer(ctx, addedPolicy)
if err != nil {
return nil, err
}
if addedPolicy.State == domain.PolicyStateActive {
return nil, caos_errs.ThrowAlreadyExists(nil, "ORG-1M8ds", "Errors.Org.OrgIAMPolicy.AlreadyExists")
return nil, caos_errs.ThrowAlreadyExists(nil, "ORG-1M8ds", "Errors.Org.DomainPolicy.AlreadyExists")
}
return org.NewOrgIAMPolicyAddedEvent(ctx, orgAgg, policy.UserLoginMustBeDomain), nil
return org.NewOrgDomainPolicyAddedEvent(ctx, orgAgg, policy.UserLoginMustBeDomain), nil
}
func (c *Commands) ChangeOrgIAMPolicy(ctx context.Context, resourceOwner string, policy *domain.OrgIAMPolicy) (*domain.OrgIAMPolicy, error) {
func (c *Commands) ChangeOrgDomainPolicy(ctx context.Context, resourceOwner string, policy *domain.DomainPolicy) (*domain.DomainPolicy, error) {
if resourceOwner == "" {
return nil, caos_errs.ThrowInvalidArgument(nil, "Org-5H8fs", "Errors.ResourceOwnerMissing")
}
existingPolicy, err := c.orgIAMPolicyWriteModelByID(ctx, resourceOwner)
existingPolicy, err := c.orgDomainPolicyWriteModelByID(ctx, resourceOwner)
if err != nil {
return nil, err
}
if existingPolicy.State == domain.PolicyStateUnspecified || existingPolicy.State == domain.PolicyStateRemoved {
return nil, caos_errs.ThrowNotFound(nil, "ORG-2N9sd", "Errors.Org.OrgIAMPolicy.NotFound")
return nil, caos_errs.ThrowNotFound(nil, "ORG-2N9sd", "Errors.Org.DomainPolicy.NotFound")
}
orgAgg := OrgAggregateFromWriteModel(&existingPolicy.PolicyOrgIAMWriteModel.WriteModel)
orgAgg := OrgAggregateFromWriteModel(&existingPolicy.PolicyDomainWriteModel.WriteModel)
changedEvent, hasChanged := existingPolicy.NewChangedEvent(ctx, orgAgg, policy.UserLoginMustBeDomain)
if !hasChanged {
return nil, caos_errs.ThrowPreconditionFailed(nil, "ORG-3M9ds", "Errors.Org.LabelPolicy.NotChanged")
@@ -68,14 +68,14 @@ func (c *Commands) ChangeOrgIAMPolicy(ctx context.Context, resourceOwner string,
if err != nil {
return nil, err
}
return orgWriteModelToOrgIAMPolicy(existingPolicy), nil
return orgWriteModelToDomainPolicy(existingPolicy), nil
}
func (c *Commands) RemoveOrgIAMPolicy(ctx context.Context, orgID string) error {
func (c *Commands) RemoveOrgDomainPolicy(ctx context.Context, orgID string) error {
if orgID == "" {
return caos_errs.ThrowInvalidArgument(nil, "Org-3H8fs", "Errors.ResourceOwnerMissing")
}
existingPolicy, err := c.orgIAMPolicyWriteModelByID(ctx, orgID)
existingPolicy, err := c.orgDomainPolicyWriteModelByID(ctx, orgID)
if err != nil {
return err
}
@@ -83,27 +83,27 @@ func (c *Commands) RemoveOrgIAMPolicy(ctx context.Context, orgID string) error {
return caos_errs.ThrowNotFound(nil, "ORG-Dvsh3", "Errors.Org.OrgIAMPolicy.NotFound")
}
orgAgg := OrgAggregateFromWriteModel(&existingPolicy.PolicyOrgIAMWriteModel.WriteModel)
_, err = c.eventstore.Push(ctx, org.NewOrgIAMPolicyRemovedEvent(ctx, orgAgg))
orgAgg := OrgAggregateFromWriteModel(&existingPolicy.PolicyDomainWriteModel.WriteModel)
_, err = c.eventstore.Push(ctx, org.NewOrgDomainPolicyRemovedEvent(ctx, orgAgg))
return err
}
func (c *Commands) getOrgIAMPolicy(ctx context.Context, orgID string) (*domain.OrgIAMPolicy, error) {
policy, err := c.orgIAMPolicyWriteModelByID(ctx, orgID)
func (c *Commands) getOrgDomainPolicy(ctx context.Context, orgID string) (*domain.DomainPolicy, error) {
policy, err := c.orgDomainPolicyWriteModelByID(ctx, orgID)
if err != nil {
return nil, err
}
if policy.State == domain.PolicyStateActive {
return orgWriteModelToOrgIAMPolicy(policy), nil
return orgWriteModelToDomainPolicy(policy), nil
}
return c.getDefaultOrgIAMPolicy(ctx)
return c.getDefaultDomainPolicy(ctx)
}
func (c *Commands) orgIAMPolicyWriteModelByID(ctx context.Context, orgID string) (policy *ORGOrgIAMPolicyWriteModel, err error) {
func (c *Commands) orgDomainPolicyWriteModelByID(ctx context.Context, orgID string) (policy *OrgDomainPolicyWriteModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
writeModel := NewORGOrgIAMPolicyWriteModel(orgID)
writeModel := NewOrgDomainPolicyWriteModel(orgID)
err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
if err != nil {
return nil, err
@@ -0,0 +1,72 @@
package command
import (
"context"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/repository/policy"
)
type OrgDomainPolicyWriteModel struct {
PolicyDomainWriteModel
}
func NewOrgDomainPolicyWriteModel(orgID string) *OrgDomainPolicyWriteModel {
return &OrgDomainPolicyWriteModel{
PolicyDomainWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: orgID,
ResourceOwner: orgID,
},
},
}
}
func (wm *OrgDomainPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *org.OrgDomainPolicyAddedEvent:
wm.PolicyDomainWriteModel.AppendEvents(&e.DomainPolicyAddedEvent)
case *org.OrgDomainPolicyChangedEvent:
wm.PolicyDomainWriteModel.AppendEvents(&e.DomainPolicyChangedEvent)
case *org.OrgDomainPolicyRemovedEvent:
wm.PolicyDomainWriteModel.AppendEvents(&e.DomainPolicyRemovedEvent)
}
}
}
func (wm *OrgDomainPolicyWriteModel) Reduce() error {
return wm.PolicyDomainWriteModel.Reduce()
}
func (wm *OrgDomainPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(org.AggregateType).
AggregateIDs(wm.PolicyDomainWriteModel.AggregateID).
EventTypes(org.OrgDomainPolicyAddedEventType,
org.OrgDomainPolicyChangedEventType,
org.OrgDomainPolicyRemovedEventType).
Builder()
}
func (wm *OrgDomainPolicyWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
userLoginMustBeDomain bool) (*org.OrgDomainPolicyChangedEvent, bool) {
changes := make([]policy.OrgPolicyChanges, 0)
if wm.UserLoginMustBeDomain != userLoginMustBeDomain {
changes = append(changes, policy.ChangeUserLoginMustBeDomain(userLoginMustBeDomain))
}
if len(changes) == 0 {
return nil, false
}
changedEvent, err := org.NewOrgDomainPolicyChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
return changedEvent, true
}
@@ -15,17 +15,17 @@ import (
"github.com/caos/zitadel/internal/repository/policy"
)
func TestCommandSide_AddOrgIAMPolicy(t *testing.T) {
func TestCommandSide_AddDomainPolicy(t *testing.T) {
type fields struct {
eventstore *eventstore.Eventstore
}
type args struct {
ctx context.Context
orgID string
policy *domain.OrgIAMPolicy
policy *domain.DomainPolicy
}
type res struct {
want *domain.OrgIAMPolicy
want *domain.DomainPolicy
err func(error) bool
}
tests := []struct {
@@ -43,7 +43,7 @@ func TestCommandSide_AddOrgIAMPolicy(t *testing.T) {
},
args: args{
ctx: context.Background(),
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: true,
},
},
@@ -58,7 +58,7 @@ func TestCommandSide_AddOrgIAMPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
org.NewOrgIAMPolicyAddedEvent(context.Background(),
org.NewOrgDomainPolicyAddedEvent(context.Background(),
&org.NewAggregate("org1", "org1").Aggregate,
true,
),
@@ -69,7 +69,7 @@ func TestCommandSide_AddOrgIAMPolicy(t *testing.T) {
args: args{
ctx: context.Background(),
orgID: "org1",
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: true,
},
},
@@ -86,7 +86,7 @@ func TestCommandSide_AddOrgIAMPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
org.NewOrgIAMPolicyAddedEvent(context.Background(),
org.NewOrgDomainPolicyAddedEvent(context.Background(),
&org.NewAggregate("org1", "org1").Aggregate,
true,
),
@@ -98,12 +98,12 @@ func TestCommandSide_AddOrgIAMPolicy(t *testing.T) {
args: args{
ctx: context.Background(),
orgID: "org1",
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: true,
},
},
res: res{
want: &domain.OrgIAMPolicy{
want: &domain.DomainPolicy{
ObjectRoot: models.ObjectRoot{
AggregateID: "org1",
ResourceOwner: "org1",
@@ -118,7 +118,7 @@ func TestCommandSide_AddOrgIAMPolicy(t *testing.T) {
r := &Commands{
eventstore: tt.fields.eventstore,
}
got, err := r.AddOrgIAMPolicy(tt.args.ctx, tt.args.orgID, tt.args.policy)
got, err := r.AddOrgDomainPolicy(tt.args.ctx, tt.args.orgID, tt.args.policy)
if tt.res.err == nil {
assert.NoError(t, err)
}
@@ -132,17 +132,17 @@ func TestCommandSide_AddOrgIAMPolicy(t *testing.T) {
}
}
func TestCommandSide_ChangeOrgIAMPolicy(t *testing.T) {
func TestCommandSide_ChangeDomainPolicy(t *testing.T) {
type fields struct {
eventstore *eventstore.Eventstore
}
type args struct {
ctx context.Context
orgID string
policy *domain.OrgIAMPolicy
policy *domain.DomainPolicy
}
type res struct {
want *domain.OrgIAMPolicy
want *domain.DomainPolicy
err func(error) bool
}
tests := []struct {
@@ -160,7 +160,7 @@ func TestCommandSide_ChangeOrgIAMPolicy(t *testing.T) {
},
args: args{
ctx: context.Background(),
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: true,
},
},
@@ -179,7 +179,7 @@ func TestCommandSide_ChangeOrgIAMPolicy(t *testing.T) {
args: args{
ctx: context.Background(),
orgID: "org1",
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: true,
},
},
@@ -194,7 +194,7 @@ func TestCommandSide_ChangeOrgIAMPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
org.NewOrgIAMPolicyAddedEvent(context.Background(),
org.NewOrgDomainPolicyAddedEvent(context.Background(),
&org.NewAggregate("org1", "org1").Aggregate,
true,
),
@@ -205,7 +205,7 @@ func TestCommandSide_ChangeOrgIAMPolicy(t *testing.T) {
args: args{
ctx: context.Background(),
orgID: "org1",
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: true,
},
},
@@ -220,7 +220,7 @@ func TestCommandSide_ChangeOrgIAMPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
org.NewOrgIAMPolicyAddedEvent(context.Background(),
org.NewOrgDomainPolicyAddedEvent(context.Background(),
&org.NewAggregate("org1", "org1").Aggregate,
true,
),
@@ -238,12 +238,12 @@ func TestCommandSide_ChangeOrgIAMPolicy(t *testing.T) {
args: args{
ctx: context.Background(),
orgID: "org1",
policy: &domain.OrgIAMPolicy{
policy: &domain.DomainPolicy{
UserLoginMustBeDomain: false,
},
},
res: res{
want: &domain.OrgIAMPolicy{
want: &domain.DomainPolicy{
ObjectRoot: models.ObjectRoot{
AggregateID: "org1",
ResourceOwner: "org1",
@@ -258,7 +258,7 @@ func TestCommandSide_ChangeOrgIAMPolicy(t *testing.T) {
r := &Commands{
eventstore: tt.fields.eventstore,
}
got, err := r.ChangeOrgIAMPolicy(tt.args.ctx, tt.args.orgID, tt.args.policy)
got, err := r.ChangeOrgDomainPolicy(tt.args.ctx, tt.args.orgID, tt.args.policy)
if tt.res.err == nil {
assert.NoError(t, err)
}
@@ -327,7 +327,7 @@ func TestCommandSide_RemoveOrgIAMPolicy(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
org.NewOrgIAMPolicyAddedEvent(context.Background(),
org.NewOrgDomainPolicyAddedEvent(context.Background(),
&org.NewAggregate("org1", "org1").Aggregate,
true,
),
@@ -336,7 +336,7 @@ func TestCommandSide_RemoveOrgIAMPolicy(t *testing.T) {
expectPush(
[]*repository.Event{
eventFromEventPusher(
org.NewOrgIAMPolicyRemovedEvent(context.Background(),
org.NewOrgDomainPolicyRemovedEvent(context.Background(),
&org.NewAggregate("org1", "org1").Aggregate),
),
},
@@ -359,7 +359,7 @@ func TestCommandSide_RemoveOrgIAMPolicy(t *testing.T) {
r := &Commands{
eventstore: tt.fields.eventstore,
}
err := r.RemoveOrgIAMPolicy(tt.args.ctx, tt.args.orgID)
err := r.RemoveOrgDomainPolicy(tt.args.ctx, tt.args.orgID)
if tt.res.err == nil {
assert.NoError(t, err)
}
@@ -370,10 +370,10 @@ func TestCommandSide_RemoveOrgIAMPolicy(t *testing.T) {
}
}
func newOrgIAMPolicyChangedEvent(ctx context.Context, orgID string, userLoginMustBeDomain bool) *org.OrgIAMPolicyChangedEvent {
event, _ := org.NewOrgIAMPolicyChangedEvent(ctx,
func newOrgIAMPolicyChangedEvent(ctx context.Context, orgID string, userLoginMustBeDomain bool) *org.OrgDomainPolicyChangedEvent {
event, _ := org.NewOrgDomainPolicyChangedEvent(ctx,
&org.NewAggregate(orgID, orgID).Aggregate,
[]policy.OrgIAMPolicyChanges{
[]policy.OrgPolicyChanges{
policy.ChangeUserLoginMustBeDomain(userLoginMustBeDomain),
},
)
+11 -11
View File
@@ -12,7 +12,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/repository/policy"
"github.com/caos/zitadel/internal/static"
@@ -111,8 +111,8 @@ func TestCommandSide_AddLabelPolicy(t *testing.T) {
expectFilter(),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -159,8 +159,8 @@ func TestCommandSide_AddLabelPolicy(t *testing.T) {
expectFilter(),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -340,8 +340,8 @@ func TestCommandSide_ChangeLabelPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -405,8 +405,8 @@ func TestCommandSide_ChangeLabelPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
@@ -470,8 +470,8 @@ func TestCommandSide_ChangeLabelPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLabelPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLabelPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"#ffffff",
"#ffffff",
"#ffffff",
+1 -1
View File
@@ -196,7 +196,7 @@ func (c *Commands) AddIDPProviderToLoginPolicy(ctx context.Context, resourceOwne
if idpProvider.Type == domain.IdentityProviderTypeOrg {
_, err = c.getOrgIDPConfigByID(ctx, idpProvider.IDPConfigID, resourceOwner)
} else {
_, err = c.getIAMIDPConfigByID(ctx, idpProvider.IDPConfigID)
_, err = c.getInstanceIDPConfigByID(ctx, idpProvider.IDPConfigID)
}
if err != nil {
return nil, caos_errs.ThrowPreconditionFailed(err, "Org-3N9fs", "Errors.IDPConfig.NotExisting")
@@ -3,7 +3,7 @@ package command
import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/org"
)
@@ -132,10 +132,10 @@ type factorState struct {
func (wm *OrgAuthFactorsAllowedWriteModel) Reduce() error {
for _, event := range wm.Events {
switch e := event.(type) {
case *iam.LoginPolicySecondFactorAddedEvent:
case *instance.LoginPolicySecondFactorAddedEvent:
wm.ensureSecondFactor(e.MFAType)
wm.SecondFactors[e.MFAType].IAM = domain.FactorStateActive
case *iam.LoginPolicySecondFactorRemovedEvent:
case *instance.LoginPolicySecondFactorRemovedEvent:
wm.ensureSecondFactor(e.MFAType)
wm.SecondFactors[e.MFAType].IAM = domain.FactorStateRemoved
case *org.LoginPolicySecondFactorAddedEvent:
@@ -144,10 +144,10 @@ func (wm *OrgAuthFactorsAllowedWriteModel) Reduce() error {
case *org.LoginPolicySecondFactorRemovedEvent:
wm.ensureSecondFactor(e.MFAType)
wm.SecondFactors[e.MFAType].Org = domain.FactorStateRemoved
case *iam.LoginPolicyMultiFactorAddedEvent:
case *instance.LoginPolicyMultiFactorAddedEvent:
wm.ensureMultiFactor(e.MFAType)
wm.MultiFactors[e.MFAType].IAM = domain.FactorStateActive
case *iam.LoginPolicyMultiFactorRemovedEvent:
case *instance.LoginPolicyMultiFactorRemovedEvent:
wm.ensureMultiFactor(e.MFAType)
wm.MultiFactors[e.MFAType].IAM = domain.FactorStateRemoved
case *org.LoginPolicyMultiFactorAddedEvent:
@@ -185,13 +185,13 @@ func (wm *OrgAuthFactorsAllowedWriteModel) ensureMultiFactor(multiFactor domain.
func (wm *OrgAuthFactorsAllowedWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateTypes(instance.AggregateType).
AggregateIDs(domain.IAMID).
EventTypes(
iam.LoginPolicySecondFactorAddedEventType,
iam.LoginPolicySecondFactorRemovedEventType,
iam.LoginPolicyMultiFactorAddedEventType,
iam.LoginPolicyMultiFactorRemovedEventType,
instance.LoginPolicySecondFactorAddedEventType,
instance.LoginPolicySecondFactorRemovedEventType,
instance.LoginPolicyMultiFactorAddedEventType,
instance.LoginPolicyMultiFactorRemovedEventType,
).
Or().
AggregateTypes(org.AggregateType).
+11 -11
View File
@@ -12,7 +12,7 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/repository"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/repository/policy"
"github.com/caos/zitadel/internal/repository/user"
@@ -118,8 +118,8 @@ func TestCommandSide_AddLoginPolicy(t *testing.T) {
expectFilter(),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
false,
true,
true,
@@ -165,8 +165,8 @@ func TestCommandSide_AddLoginPolicy(t *testing.T) {
expectFilter(),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
false,
true,
true,
@@ -351,8 +351,8 @@ func TestCommandSide_ChangeLoginPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
false,
true,
true,
@@ -415,8 +415,8 @@ func TestCommandSide_ChangeLoginPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
false,
true,
true,
@@ -480,8 +480,8 @@ func TestCommandSide_ChangeLoginPolicy(t *testing.T) {
),
expectFilter(
eventFromEventPusher(
iam.NewLoginPolicyAddedEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewLoginPolicyAddedEvent(context.Background(),
&instance.NewAggregate().Aggregate,
false,
false,
false,
@@ -1,72 +0,0 @@
package command
import (
"context"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/repository/policy"
)
type ORGOrgIAMPolicyWriteModel struct {
PolicyOrgIAMWriteModel
}
func NewORGOrgIAMPolicyWriteModel(orgID string) *ORGOrgIAMPolicyWriteModel {
return &ORGOrgIAMPolicyWriteModel{
PolicyOrgIAMWriteModel{
WriteModel: eventstore.WriteModel{
AggregateID: orgID,
ResourceOwner: orgID,
},
},
}
}
func (wm *ORGOrgIAMPolicyWriteModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *org.OrgIAMPolicyAddedEvent:
wm.PolicyOrgIAMWriteModel.AppendEvents(&e.OrgIAMPolicyAddedEvent)
case *org.OrgIAMPolicyChangedEvent:
wm.PolicyOrgIAMWriteModel.AppendEvents(&e.OrgIAMPolicyChangedEvent)
case *org.OrgIAMPolicyRemovedEvent:
wm.PolicyOrgIAMWriteModel.AppendEvents(&e.OrgIAMPolicyRemovedEvent)
}
}
}
func (wm *ORGOrgIAMPolicyWriteModel) Reduce() error {
return wm.PolicyOrgIAMWriteModel.Reduce()
}
func (wm *ORGOrgIAMPolicyWriteModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(wm.ResourceOwner).
AddQuery().
AggregateTypes(org.AggregateType).
AggregateIDs(wm.PolicyOrgIAMWriteModel.AggregateID).
EventTypes(org.OrgIAMPolicyAddedEventType,
org.OrgIAMPolicyChangedEventType,
org.OrgIAMPolicyRemovedEventType).
Builder()
}
func (wm *ORGOrgIAMPolicyWriteModel) NewChangedEvent(
ctx context.Context,
aggregate *eventstore.Aggregate,
userLoginMustBeDomain bool) (*org.OrgIAMPolicyChangedEvent, bool) {
changes := make([]policy.OrgIAMPolicyChanges, 0)
if wm.UserLoginMustBeDomain != userLoginMustBeDomain {
changes = append(changes, policy.ChangeUserLoginMustBeDomain(userLoginMustBeDomain))
}
if len(changes) == 0 {
return nil, false
}
changedEvent, err := org.NewOrgIAMPolicyChangedEvent(ctx, aggregate, changes)
if err != nil {
return nil, false
}
return changedEvent, true
}
@@ -6,20 +6,20 @@ import (
"github.com/caos/zitadel/internal/repository/policy"
)
type PolicyOrgIAMWriteModel struct {
type PolicyDomainWriteModel struct {
eventstore.WriteModel
UserLoginMustBeDomain bool
State domain.PolicyState
}
func (wm *PolicyOrgIAMWriteModel) Reduce() error {
func (wm *PolicyDomainWriteModel) Reduce() error {
for _, event := range wm.Events {
switch e := event.(type) {
case *policy.OrgIAMPolicyAddedEvent:
case *policy.DomainPolicyAddedEvent:
wm.UserLoginMustBeDomain = e.UserLoginMustBeDomain
wm.State = domain.PolicyStateActive
case *policy.OrgIAMPolicyChangedEvent:
case *policy.DomainPolicyChangedEvent:
if e.UserLoginMustBeDomain != nil {
wm.UserLoginMustBeDomain = *e.UserLoginMustBeDomain
}
+1 -1
View File
@@ -38,7 +38,7 @@ func (c *Commands) addProject(ctx context.Context, projectAdd *domain.Project, r
projectAgg := ProjectAggregateFromWriteModel(&addedProject.WriteModel)
projectRole := domain.RoleProjectOwner
iam, err := c.GetIAM(ctx)
iam, err := c.GetInstance(ctx)
if err != nil {
return nil, nil, err
}
+7 -7
View File
@@ -13,7 +13,7 @@ import (
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/id"
id_mock "github.com/caos/zitadel/internal/id/mock"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/instance"
"github.com/caos/zitadel/internal/repository/member"
"github.com/caos/zitadel/internal/repository/project"
)
@@ -62,8 +62,8 @@ func TestCommandSide_AddProject(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewGlobalOrgSetEventEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewGlobalOrgSetEventEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"globalorg",
),
),
@@ -114,8 +114,8 @@ func TestCommandSide_AddProject(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewGlobalOrgSetEventEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewGlobalOrgSetEventEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"globalorg",
),
),
@@ -176,8 +176,8 @@ func TestCommandSide_AddProject(t *testing.T) {
t,
expectFilter(
eventFromEventPusher(
iam.NewGlobalOrgSetEventEvent(context.Background(),
&iam.NewAggregate().Aggregate,
instance.NewGlobalOrgSetEventEvent(context.Background(),
&instance.NewAggregate().Aggregate,
"globalorg",
),
),
+8 -8
View File
@@ -10,7 +10,7 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore/v1/models"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
iam_repo "github.com/caos/zitadel/internal/repository/instance"
)
type Step interface {
@@ -23,7 +23,7 @@ const (
)
func (c *Commands) ExecuteSetupSteps(ctx context.Context, steps []Step) error {
iam, err := c.GetIAM(ctx)
iam, err := c.GetInstance(ctx)
if err != nil && !caos_errs.IsNotFound(err) {
return err
}
@@ -33,7 +33,7 @@ func (c *Commands) ExecuteSetupSteps(ctx context.Context, steps []Step) error {
}
if iam == nil {
iam = &domain.IAM{ObjectRoot: models.ObjectRoot{}}
iam = &domain.Instance{ObjectRoot: models.ObjectRoot{}}
}
ctx = setSetUpContextData(ctx)
@@ -56,7 +56,7 @@ func setSetUpContextData(ctx context.Context) context.Context {
return authz.SetCtxData(ctx, authz.CtxData{UserID: SetupUser})
}
func (c *Commands) StartSetup(ctx context.Context, step domain.Step) (*domain.IAM, error) {
func (c *Commands) StartSetup(ctx context.Context, step domain.Step) (*domain.Instance, error) {
logging.Log("COMMA-3M9fs").Infof("start setup step %v", step)
iamWriteModel, err := c.getIAMWriteModel(ctx)
if err != nil && !caos_errs.IsNotFound(err) {
@@ -65,7 +65,7 @@ func (c *Commands) StartSetup(ctx context.Context, step domain.Step) (*domain.IA
if iamWriteModel.SetUpStarted >= step || iamWriteModel.SetUpStarted != iamWriteModel.SetUpDone {
return nil, caos_errs.ThrowPreconditionFailed(nil, "EVENT-9so34", "setup error")
}
aggregate := IAMAggregateFromWriteModel(&iamWriteModel.WriteModel)
aggregate := InstanceAggregateFromWriteModel(&iamWriteModel.WriteModel)
pushedEvents, err := c.eventstore.Push(ctx, iam_repo.NewSetupStepStartedEvent(ctx, aggregate, step))
if err != nil {
return nil, caos_errs.ThrowPreconditionFailed(nil, "EVENT-Grgh1", "Setup start failed")
@@ -75,10 +75,10 @@ func (c *Commands) StartSetup(ctx context.Context, step domain.Step) (*domain.IA
return nil, err
}
logging.LogWithFields("SETUP-fhh21", "step", step).Info("setup step started")
return writeModelToIAM(iamWriteModel), nil
return writeModelToInstance(iamWriteModel), nil
}
func (c *Commands) setup(ctx context.Context, step Step, iamAggregateProvider func(*IAMWriteModel) ([]eventstore.Command, error)) error {
func (c *Commands) setup(ctx context.Context, step Step, iamAggregateProvider func(*InstanceWriteModel) ([]eventstore.Command, error)) error {
iam, err := c.getIAMWriteModel(ctx)
if err != nil && !caos_errs.IsNotFound(err) {
return err
@@ -90,7 +90,7 @@ func (c *Commands) setup(ctx context.Context, step Step, iamAggregateProvider fu
if err != nil {
return err
}
iamAgg := IAMAggregateFromWriteModel(&iam.WriteModel)
iamAgg := InstanceAggregateFromWriteModel(&iam.WriteModel)
events = append(events, iam_repo.NewSetupStepDoneEvent(ctx, iamAgg, step.Step()))
_, err = c.eventstore.Push(ctx, events...)
+7 -7
View File
@@ -12,7 +12,7 @@ import (
"github.com/caos/zitadel/internal/domain"
caos_errs "github.com/caos/zitadel/internal/errors"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
iam_repo "github.com/caos/zitadel/internal/repository/instance"
)
const (
@@ -94,10 +94,10 @@ type API struct {
func (c *Commands) SetupStep1(ctx context.Context, step1 *Step1) error {
var events []eventstore.Command
iamWriteModel := NewIAMWriteModel()
iamAgg := IAMAggregateFromWriteModel(&iamWriteModel.WriteModel)
iamWriteModel := NewInstanceWriteModel()
iamAgg := InstanceAggregateFromWriteModel(&iamWriteModel.WriteModel)
//create default login policy
loginPolicyEvent, err := c.addDefaultLoginPolicy(ctx, iamAgg, NewIAMLoginPolicyWriteModel(),
loginPolicyEvent, err := c.addDefaultLoginPolicy(ctx, iamAgg, NewInstanceLoginPolicyWriteModel(),
&domain.LoginPolicy{
AllowUsernamePassword: step1.DefaultLoginPolicy.AllowUsernamePassword,
AllowRegister: step1.DefaultLoginPolicy.AllowRegister,
@@ -110,7 +110,7 @@ func (c *Commands) SetupStep1(ctx context.Context, step1 *Step1) error {
logging.Log("SETUP-sd2hj").Info("default login policy set up")
//create orgs
for _, organisation := range step1.Orgs {
orgIAMPolicy := &domain.OrgIAMPolicy{UserLoginMustBeDomain: true}
orgIAMPolicy := &domain.DomainPolicy{UserLoginMustBeDomain: true}
if organisation.OrgIamPolicy {
orgIAMPolicy.UserLoginMustBeDomain = false
}
@@ -146,7 +146,7 @@ func (c *Commands) SetupStep1(ctx context.Context, step1 *Step1) error {
logging.LogWithFields("SETUP-Gdsfg", "id", orgAgg.ID, "name", organisation.Name).Info("org set up")
if organisation.OrgIamPolicy {
orgIAMPolicyEvent, err := c.addOrgIAMPolicy(ctx, orgAgg, NewORGOrgIAMPolicyWriteModel(orgAgg.ID), orgIAMPolicy)
orgIAMPolicyEvent, err := c.addOrgDomainPolicy(ctx, orgAgg, NewOrgDomainPolicyWriteModel(orgAgg.ID), orgIAMPolicy)
if err != nil {
return err
}
@@ -175,7 +175,7 @@ func (c *Commands) SetupStep1(ctx context.Context, step1 *Step1) error {
}
events = append(events, iamProjectEvent)
logging.Log("SETUP-Bdfs1").Info("IAM project set")
iamEvent, err := c.addIAMMember(ctx, iamAgg, NewIAMMemberWriteModel(humanWriteModel.AggregateID), domain.NewMember(iamAgg.ID, humanWriteModel.AggregateID, domain.RoleIAMOwner))
iamEvent, err := c.addInstanceMember(ctx, iamAgg, NewInstanceMemberWriteModel(humanWriteModel.AggregateID), domain.NewMember(iamAgg.ID, humanWriteModel.AggregateID, domain.RoleIAMOwner))
if err != nil {
return err
}
+3 -3
View File
@@ -22,9 +22,9 @@ func (s *Step10) execute(ctx context.Context, commandSide *Commands) error {
}
func (c *Commands) SetupStep10(ctx context.Context, step *Step10) error {
fn := func(iam *IAMWriteModel) ([]eventstore.Command, error) {
iamAgg := IAMAggregateFromWriteModel(&iam.WriteModel)
mailTemplateEvent, err := c.addDefaultMailTemplate(ctx, iamAgg, NewIAMMailTemplateWriteModel(), &step.DefaultMailTemplate)
fn := func(iam *InstanceWriteModel) ([]eventstore.Command, error) {
iamAgg := InstanceAggregateFromWriteModel(&iam.WriteModel)
mailTemplateEvent, err := c.addDefaultMailTemplate(ctx, iamAgg, NewInstanceMailTemplateWriteModel(), &step.DefaultMailTemplate)
if err != nil {
return nil, err
}
+3 -3
View File
@@ -6,7 +6,7 @@ import (
"github.com/caos/logging"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
iam_repo "github.com/caos/zitadel/internal/repository/instance"
)
type Step11 struct {
@@ -22,8 +22,8 @@ func (s *Step11) execute(ctx context.Context, commandSide *Commands) error {
}
func (c *Commands) SetupStep11(ctx context.Context, step *Step11) error {
fn := func(iam *IAMWriteModel) ([]eventstore.Command, error) {
iamAgg := IAMAggregateFromWriteModel(&iam.WriteModel)
fn := func(iam *InstanceWriteModel) ([]eventstore.Command, error) {
iamAgg := InstanceAggregateFromWriteModel(&iam.WriteModel)
var uniqueContraintMigrations []*domain.UniqueConstraintMigration
if step.MigrateV1EventstoreToV2 {
uniqueConstraints := NewUniqueConstraintReadModel(ctx, c)
+2 -2
View File
@@ -31,8 +31,8 @@ func (s *Step12) execute(ctx context.Context, commandSide *Commands) error {
}
func (c *Commands) SetupStep12(ctx context.Context, step *Step12) error {
fn := func(iam *IAMWriteModel) ([]eventstore.Command, error) {
featuresWriteModel := NewIAMFeaturesWriteModel()
fn := func(iam *InstanceWriteModel) ([]eventstore.Command, error) {
featuresWriteModel := NewInstanceFeaturesWriteModel()
featuresEvent, err := c.setDefaultFeatures(ctx, featuresWriteModel, &domain.Features{
TierName: step.TierName,
TierDescription: step.TierDescription,
+1 -1
View File
@@ -21,7 +21,7 @@ func (s *Step13) execute(ctx context.Context, commandSide *Commands) error {
}
func (c *Commands) SetupStep13(ctx context.Context, step *Step13) error {
fn := func(iam *IAMWriteModel) ([]eventstore.Command, error) {
fn := func(iam *InstanceWriteModel) ([]eventstore.Command, error) {
_, mailTemplateEvent, err := c.changeDefaultMailTemplate(ctx, &step.DefaultMailTemplate)
if err != nil {
return nil, err
+3 -3
View File
@@ -7,7 +7,7 @@ import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
iam_repo "github.com/caos/zitadel/internal/repository/iam"
iam_repo "github.com/caos/zitadel/internal/repository/instance"
org_repo "github.com/caos/zitadel/internal/repository/org"
)
@@ -24,8 +24,8 @@ func (s *Step14) execute(ctx context.Context, commandSide *Commands) error {
}
func (c *Commands) SetupStep14(ctx context.Context, step *Step14) error {
fn := func(iam *IAMWriteModel) ([]eventstore.Command, error) {
iamAgg := IAMAggregateFromWriteModel(&iam.WriteModel)
fn := func(iam *InstanceWriteModel) ([]eventstore.Command, error) {
iamAgg := InstanceAggregateFromWriteModel(&iam.WriteModel)
var events []eventstore.Command
if step.ActivateExistingLabelPolicies {
existingPolicies := NewExistingLabelPoliciesReadModel(ctx)
+1 -1
View File
@@ -21,7 +21,7 @@ func (s *Step15) execute(ctx context.Context, commandSide *Commands) error {
}
func (c *Commands) SetupStep15(ctx context.Context, step *Step15) error {
fn := func(iam *IAMWriteModel) ([]eventstore.Command, error) {
fn := func(iam *InstanceWriteModel) ([]eventstore.Command, error) {
_, mailTemplateEvent, err := c.changeDefaultMailTemplate(ctx, &step.DefaultMailTemplate)
if err != nil {
return nil, err
+2 -2
View File
@@ -21,8 +21,8 @@ func (s *Step16) execute(ctx context.Context, commandSide *Commands) error {
}
func (c *Commands) SetupStep16(ctx context.Context, step *Step16) error {
fn := func(iam *IAMWriteModel) ([]eventstore.Command, error) {
iamAgg := IAMAggregateFromWriteModel(&iam.WriteModel)
fn := func(iam *InstanceWriteModel) ([]eventstore.Command, error) {
iamAgg := InstanceAggregateFromWriteModel(&iam.WriteModel)
events := make([]eventstore.Command, 0)
for _, text := range step.DefaultMessageTexts {
+3 -3
View File
@@ -21,9 +21,9 @@ func (s *Step17) execute(ctx context.Context, commandSide *Commands) error {
}
func (c *Commands) SetupStep17(ctx context.Context, step *Step17) error {
fn := func(iam *IAMWriteModel) ([]eventstore.Command, error) {
iamAgg := IAMAggregateFromWriteModel(&iam.WriteModel)
addedPolicy := NewIAMPrivacyPolicyWriteModel()
fn := func(iam *InstanceWriteModel) ([]eventstore.Command, error) {
iamAgg := InstanceAggregateFromWriteModel(&iam.WriteModel)
addedPolicy := NewInstancePrivacyPolicyWriteModel()
events, err := c.addDefaultPrivacyPolicy(ctx, iamAgg, addedPolicy, &step.PrivacyPolicy)
if err != nil {
return nil, err
+3 -3
View File
@@ -21,9 +21,9 @@ func (s *Step18) execute(ctx context.Context, commandSide *Commands) error {
}
func (c *Commands) SetupStep18(ctx context.Context, step *Step18) error {
fn := func(iam *IAMWriteModel) ([]eventstore.Command, error) {
iamAgg := IAMAggregateFromWriteModel(&iam.WriteModel)
addedPolicy := NewIAMLockoutPolicyWriteModel()
fn := func(iam *InstanceWriteModel) ([]eventstore.Command, error) {
iamAgg := InstanceAggregateFromWriteModel(&iam.WriteModel)
addedPolicy := NewInstanceLockoutPolicyWriteModel()
events, err := c.addDefaultLockoutPolicy(ctx, iamAgg, addedPolicy, &step.LockoutPolicy)
if err != nil {
return nil, err

Some files were not shown because too many files have changed in this diff Show More