new pkg structure (#1150)

* fix: split command query side

* fix: split command query side

* fix: members in correct pkg structure

* fix: label policy in correct pkg structure

* fix: structure

* fix: structure of login policy

* fix: identityprovider structure

* fix: org iam policy structure

* fix: password age policy structure

* fix: password complexity policy structure

* fix: password lockout policy structure

* fix: idp structure

* fix: user events structure

* fix: user write model

* fix: profile email changed command

* fix: address changed command

* fix: user states

* fix: user

* fix: org structure and add human

* begin iam setup command side

* setup

* step2

* step2

* fix: add user

* step2

* isvalid

* fix: folder structure v2 business

Co-authored-by: Fabiennne <fabienne.gerschwiler@gmail.com>

internal/v2/repository/policy/label.go

@@ -1,4 +1,4 @@
-package label
+package policy
 
 import (
 	"encoding/json"
@@ -13,32 +13,32 @@ const (
 	LabelPolicyRemovedEventType = "policy.label.removed"
 )
 
-type AddedEvent struct {
+type LabelPolicyAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	PrimaryColor   string `json:"primaryColor,omitempty"`
 	SecondaryColor string `json:"secondaryColor,omitempty"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *LabelPolicyAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewLabelPolicyAddedEvent(
 	base *eventstore.BaseEvent,
 	primaryColor,
 	secondaryColor string,
-) *AddedEvent {
+) *LabelPolicyAddedEvent {
 
-	return &AddedEvent{
+	return &LabelPolicyAddedEvent{
 		BaseEvent:      *base,
 		PrimaryColor:   primaryColor,
 		SecondaryColor: secondaryColor,
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
+func LabelPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &LabelPolicyAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -50,39 +50,27 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return e, nil
 }
 
-type ChangedEvent struct {
+type LabelPolicyChangedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	PrimaryColor   string `json:"primaryColor,omitempty"`
 	SecondaryColor string `json:"secondaryColor,omitempty"`
 }
 
-func (e *ChangedEvent) Data() interface{} {
+func (e *LabelPolicyChangedEvent) Data() interface{} {
 	return e
 }
 
-func NewChangedEvent(
+func NewLabelPolicyChangedEvent(
 	base *eventstore.BaseEvent,
-	current *WriteModel,
-	primaryColor,
-	secondaryColor string,
-) *ChangedEvent {
-
-	e := &ChangedEvent{
+) *LabelPolicyChangedEvent {
+	return &LabelPolicyChangedEvent{
 		BaseEvent: *base,
 	}
-	if primaryColor != "" && current.PrimaryColor != primaryColor {
-		e.PrimaryColor = primaryColor
-	}
-	if secondaryColor != "" && current.SecondaryColor != secondaryColor {
-		e.SecondaryColor = secondaryColor
-	}
-
-	return e
 }
 
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
+func LabelPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &LabelPolicyChangedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -94,22 +82,22 @@ func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error)
 	return e, nil
 }
 
-type RemovedEvent struct {
+type LabelPolicyRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *RemovedEvent) Data() interface{} {
+func (e *LabelPolicyRemovedEvent) Data() interface{} {
 	return nil
 }
 
-func NewRemovedEvent(base *eventstore.BaseEvent) *RemovedEvent {
-	return &RemovedEvent{
+func NewRemovedEvent(base *eventstore.BaseEvent) *LabelPolicyRemovedEvent {
+	return &LabelPolicyRemovedEvent{
 		BaseEvent: *base,
 	}
 }
 
 func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &RemovedEvent{
+	return &LabelPolicyRemovedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}, nil
 }

internal/v2/repository/policy/label/read_model.go

@@ -1,24 +0,0 @@
-package label
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	PrimaryColor   string
-	SecondaryColor string
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.PrimaryColor = e.PrimaryColor
-			rm.SecondaryColor = e.SecondaryColor
-		case *ChangedEvent:
-			rm.PrimaryColor = e.PrimaryColor
-			rm.SecondaryColor = e.SecondaryColor
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/label/write_model.go

@@ -1,26 +0,0 @@
-package label
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	PrimaryColor   string
-	SecondaryColor string
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.PrimaryColor = e.PrimaryColor
-			wm.SecondaryColor = e.SecondaryColor
-		case *ChangedEvent:
-			wm.PrimaryColor = e.PrimaryColor
-			wm.SecondaryColor = e.SecondaryColor
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/login.go

@@ -0,0 +1,119 @@
+package policy
+
+import (
+	"encoding/json"
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
+)
+
+const (
+	loginPolicyPrefix           = "policy.login."
+	LoginPolicyAddedEventType   = loginPolicyPrefix + "added"
+	LoginPolicyChangedEventType = loginPolicyPrefix + "changed"
+	LoginPolicyRemovedEventType = loginPolicyPrefix + "removed"
+)
+
+type LoginPolicyAddedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	AllowUserNamePassword bool                    `json:"allowUsernamePassword"`
+	AllowRegister         bool                    `json:"allowRegister"`
+	AllowExternalIDP      bool                    `json:"allowExternalIdp"`
+	ForceMFA              bool                    `json:"forceMFA"`
+	PasswordlessType      domain.PasswordlessType `json:"passwordlessType"`
+}
+
+func (e *LoginPolicyAddedEvent) Data() interface{} {
+	return e
+}
+
+func NewLoginPolicyAddedEvent(
+	base *eventstore.BaseEvent,
+	allowUserNamePassword,
+	allowRegister,
+	allowExternalIDP,
+	forceMFA bool,
+	passwordlessType domain.PasswordlessType,
+) *LoginPolicyAddedEvent {
+	return &LoginPolicyAddedEvent{
+		BaseEvent:             *base,
+		AllowExternalIDP:      allowExternalIDP,
+		AllowRegister:         allowRegister,
+		AllowUserNamePassword: allowUserNamePassword,
+		ForceMFA:              forceMFA,
+		PasswordlessType:      passwordlessType,
+	}
+}
+
+func LoginPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &LoginPolicyAddedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "POLIC-nWndT", "unable to unmarshal policy")
+	}
+
+	return e, nil
+}
+
+type LoginPolicyChangedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+
+	AllowUserNamePassword bool                    `json:"allowUsernamePassword,omitempty"`
+	AllowRegister         bool                    `json:"allowRegister"`
+	AllowExternalIDP      bool                    `json:"allowExternalIdp"`
+	ForceMFA              bool                    `json:"forceMFA"`
+	PasswordlessType      domain.PasswordlessType `json:"passwordlessType"`
+}
+
+type LoginPolicyEventData struct {
+}
+
+func (e *LoginPolicyChangedEvent) Data() interface{} {
+	return e
+}
+
+func NewLoginPolicyChangedEvent(
+	base *eventstore.BaseEvent,
+) *LoginPolicyChangedEvent {
+	return &LoginPolicyChangedEvent{
+		BaseEvent: *base,
+	}
+}
+
+func LoginPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &LoginPolicyChangedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "POLIC-ehssl", "unable to unmarshal policy")
+	}
+
+	return e, nil
+}
+
+type LoginPolicyRemovedEvent struct {
+	eventstore.BaseEvent `json:"-"`
+}
+
+func (e *LoginPolicyRemovedEvent) Data() interface{} {
+	return nil
+}
+
+func NewLoginPolicyRemovedEvent(base *eventstore.BaseEvent) *LoginPolicyRemovedEvent {
+	return &LoginPolicyRemovedEvent{
+		BaseEvent: *base,
+	}
+}
+
+func LoginPolicyRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	return &LoginPolicyRemovedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}, nil
+}

internal/v2/repository/policy/login/events.go

@@ -1,143 +0,0 @@
-package login
-
-import (
-	"encoding/json"
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-	"github.com/caos/zitadel/internal/v2/repository/policy/login/idpprovider"
-)
-
-const (
-	loginPolicyPrefix                      = "policy.login."
-	LoginPolicyAddedEventType              = loginPolicyPrefix + "added"
-	LoginPolicyChangedEventType            = loginPolicyPrefix + "changed"
-	LoginPolicyRemovedEventType            = loginPolicyPrefix + "removed"
-	LoginPolicyIDPProviderAddedEventType   = loginPolicyPrefix + idpprovider.AddedEventType
-	LoginPolicyIDPProviderRemovedEventType = loginPolicyPrefix + idpprovider.RemovedEventType
-)
-
-type AddedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	AllowUserNamePassword bool             `json:"allowUsernamePassword"`
-	AllowRegister         bool             `json:"allowRegister"`
-	AllowExternalIDP      bool             `json:"allowExternalIdp"`
-	ForceMFA              bool             `json:"forceMFA"`
-	PasswordlessType      PasswordlessType `json:"passwordlessType"`
-}
-
-func (e *AddedEvent) Data() interface{} {
-	return e
-}
-
-func NewAddedEvent(
-	base *eventstore.BaseEvent,
-	allowUserNamePassword,
-	allowRegister,
-	allowExternalIDP,
-	forceMFA bool,
-	passwordlessType PasswordlessType,
-) *AddedEvent {
-	return &AddedEvent{
-		BaseEvent:             *base,
-		AllowExternalIDP:      allowExternalIDP,
-		AllowRegister:         allowRegister,
-		AllowUserNamePassword: allowUserNamePassword,
-		ForceMFA:              forceMFA,
-		PasswordlessType:      passwordlessType,
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "POLIC-nWndT", "unable to unmarshal policy")
-	}
-
-	return e, nil
-}
-
-type ChangedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-
-	AllowUserNamePassword bool             `json:"allowUsernamePassword,omitempty"`
-	AllowRegister         bool             `json:"allowRegister"`
-	AllowExternalIDP      bool             `json:"allowExternalIdp"`
-	ForceMFA              bool             `json:"forceMFA"`
-	PasswordlessType      PasswordlessType `json:"passwordlessType"`
-}
-
-func (e *ChangedEvent) Data() interface{} {
-	return e
-}
-
-func NewChangedEvent(
-	base *eventstore.BaseEvent,
-	current *WriteModel,
-	allowUserNamePassword,
-	allowRegister,
-	allowExternalIDP,
-	forceMFA bool,
-	passwordlessType PasswordlessType,
-) *ChangedEvent {
-
-	e := &ChangedEvent{
-		BaseEvent: *base,
-	}
-
-	if current.AllowUserNamePassword != allowUserNamePassword {
-		e.AllowUserNamePassword = allowUserNamePassword
-	}
-	if current.AllowRegister != allowRegister {
-		e.AllowRegister = allowRegister
-	}
-	if current.AllowExternalIDP != allowExternalIDP {
-		e.AllowExternalIDP = allowExternalIDP
-	}
-	if current.ForceMFA != forceMFA {
-		e.ForceMFA = forceMFA
-	}
-	if current.PasswordlessType != passwordlessType {
-		e.PasswordlessType = passwordlessType
-	}
-
-	return e
-}
-
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "POLIC-ehssl", "unable to unmarshal policy")
-	}
-
-	return e, nil
-}
-
-type RemovedEvent struct {
-	eventstore.BaseEvent `json:"-"`
-}
-
-func (e *RemovedEvent) Data() interface{} {
-	return nil
-}
-
-func NewRemovedEvent(base *eventstore.BaseEvent) *RemovedEvent {
-	return &RemovedEvent{
-		BaseEvent: *base,
-	}
-}
-
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &RemovedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}, nil
-}

internal/v2/repository/policy/login/factors/factors.go

@@ -1,16 +0,0 @@
-package factors
-
-type SecondFactorType int32
-
-const (
-	SecondFactorTypeUnspecified SecondFactorType = iota
-	SecondFactorTypeOTP
-	SecondFactorTypeU2F
-)
-
-type MultiFactorType int32
-
-const (
-	MultiFactorTypeUnspecified MultiFactorType = iota
-	MultiFactorTypeU2FWithPIN
-)

internal/v2/repository/policy/login/factors/write_model.go

@@ -1,37 +0,0 @@
-package factors
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type SecondFactorWriteModel struct {
-	eventstore.WriteModel
-	MFAType SecondFactorType
-}
-
-func (wm *SecondFactorWriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *SecondFactorAddedEvent:
-			wm.MFAType = e.MFAType
-		case *SecondFactorRemovedEvent:
-			wm.MFAType = e.MFAType
-		}
-	}
-	return wm.WriteModel.Reduce()
-}
-
-type MultiFactoryWriteModel struct {
-	eventstore.WriteModel
-	MFAType MultiFactorType
-}
-
-func (wm *MultiFactoryWriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *MultiFactorAddedEvent:
-			wm.MFAType = e.MFAType
-		case *MultiFactorRemovedEvent:
-			wm.MFAType = e.MFAType
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/login/idpprovider/events.go

@@ -1,83 +0,0 @@
-package idpprovider
-
-import (
-	"encoding/json"
-	"github.com/caos/zitadel/internal/errors"
-	"github.com/caos/zitadel/internal/eventstore/v2"
-	"github.com/caos/zitadel/internal/eventstore/v2/repository"
-)
-
-const (
-	AddedEventType   = "idpprovider.added"
-	RemovedEventType = "idpprovider.removed"
-)
-
-type AddedEvent struct {
-	eventstore.BaseEvent
-
-	IDPConfigID     string `json:"idpConfigId"`
-	IDPProviderType Type   `json:"idpProviderType"`
-}
-
-func (e *AddedEvent) Data() interface{} {
-	return e
-}
-
-func NewAddedEvent(
-	base *eventstore.BaseEvent,
-	idpConfigID string,
-	idpProviderType Type,
-) *AddedEvent {
-
-	return &AddedEvent{
-		*base,
-		idpConfigID,
-		idpProviderType,
-	}
-}
-
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "PROVI-bfNnp", "Errors.Internal")
-	}
-
-	return e, nil
-}
-
-type RemovedEvent struct {
-	eventstore.BaseEvent
-
-	IDPConfigID string `json:"idpConfigId"`
-}
-
-func (e *RemovedEvent) Data() interface{} {
-	return e
-}
-
-func NewRemovedEvent(
-	base *eventstore.BaseEvent,
-	idpConfigID string,
-) *RemovedEvent {
-	return &RemovedEvent{
-		BaseEvent:   *base,
-		IDPConfigID: idpConfigID,
-	}
-}
-
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &RemovedEvent{
-		BaseEvent: *eventstore.BaseEventFromRepo(event),
-	}
-
-	err := json.Unmarshal(event.Data, e)
-	if err != nil {
-		return nil, errors.ThrowInternal(err, "PROVI-6H0KQ", "Errors.Internal")
-	}
-
-	return e, nil
-}

internal/v2/repository/policy/login/idpprovider/provider.go

@@ -1,14 +0,0 @@
-package idpprovider
-
-type Type int8
-
-const (
-	TypeSystem Type = iota
-	TypeOrg
-
-	typeCount
-)
-
-func (f Type) Valid() bool {
-	return f >= 0 && f < typeCount
-}

internal/v2/repository/policy/login/idpprovider/write_model.go

@@ -1,23 +0,0 @@
-package idpprovider
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	IDPConfigID     string
-	IDPProviderType Type
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.IDPConfigID = e.IDPConfigID
-			wm.IDPProviderType = e.IDPProviderType
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/login/login.go

@@ -1,8 +0,0 @@
-package login
-
-type PasswordlessType int32
-
-const (
-	PasswordlessTypeNotAllowed PasswordlessType = iota
-	PasswordlessTypeAllowed
-)

internal/v2/repository/policy/login/read_model.go

@@ -1,35 +0,0 @@
-package login
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	AllowUserNamePassword bool
-	AllowRegister         bool
-	AllowExternalIDP      bool
-	ForceMFA              bool
-	PasswordlessType      PasswordlessType
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.AllowUserNamePassword = e.AllowUserNamePassword
-			rm.AllowExternalIDP = e.AllowExternalIDP
-			rm.AllowRegister = e.AllowRegister
-			rm.ForceMFA = e.ForceMFA
-			rm.PasswordlessType = e.PasswordlessType
-		case *ChangedEvent:
-			rm.AllowUserNamePassword = e.AllowUserNamePassword
-			rm.AllowExternalIDP = e.AllowExternalIDP
-			rm.AllowRegister = e.AllowRegister
-			rm.ForceMFA = e.ForceMFA
-			rm.PasswordlessType = e.PasswordlessType
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/login/write_model.go

@@ -1,35 +0,0 @@
-package login
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	AllowUserNamePassword bool
-	AllowRegister         bool
-	AllowExternalIDP      bool
-	ForceMFA              bool
-	PasswordlessType      PasswordlessType
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.AllowRegister = e.AllowRegister
-			wm.AllowUserNamePassword = e.AllowUserNamePassword
-			wm.AllowExternalIDP = e.AllowExternalIDP
-			wm.ForceMFA = e.ForceMFA
-			wm.PasswordlessType = e.PasswordlessType
-		case *ChangedEvent:
-			wm.AllowRegister = e.AllowRegister
-			wm.AllowUserNamePassword = e.AllowUserNamePassword
-			wm.AllowExternalIDP = e.AllowExternalIDP
-			wm.ForceMFA = e.ForceMFA
-			wm.PasswordlessType = e.PasswordlessType
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/org_iam/read_model.go

@@ -1,21 +0,0 @@
-package org_iam
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	UserLoginMustBeDomain bool
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.UserLoginMustBeDomain = e.UserLoginMustBeDomain
-		case *ChangedEvent:
-			rm.UserLoginMustBeDomain = e.UserLoginMustBeDomain
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/org_iam/write_model.go

@@ -1,21 +0,0 @@
-package org_iam
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	UserLoginMustBeDomain bool
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.UserLoginMustBeDomain = e.UserLoginMustBeDomain
-		case *ChangedEvent:
-			wm.UserLoginMustBeDomain = e.UserLoginMustBeDomain
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/password_age/read_model.go

@@ -1,24 +0,0 @@
-package password_age
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	ExpireWarnDays uint64
-	MaxAgeDays     uint64
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.ExpireWarnDays = e.ExpireWarnDays
-			rm.MaxAgeDays = e.MaxAgeDays
-		case *ChangedEvent:
-			rm.ExpireWarnDays = e.ExpireWarnDays
-			rm.MaxAgeDays = e.MaxAgeDays
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/password_age/write_model.go

@@ -1,26 +0,0 @@
-package password_age
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	ExpireWarnDays uint64
-	MaxAgeDays     uint64
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.ExpireWarnDays = e.ExpireWarnDays
-			wm.MaxAgeDays = e.MaxAgeDays
-		case *ChangedEvent:
-			wm.ExpireWarnDays = e.ExpireWarnDays
-			wm.MaxAgeDays = e.MaxAgeDays
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/password_complexity/read_model.go

@@ -1,33 +0,0 @@
-package password_complexity
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	MinLength    uint64
-	HasLowercase bool
-	HasUpperCase bool
-	HasNumber    bool
-	HasSymbol    bool
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.MinLength = e.MinLength
-			rm.HasLowercase = e.HasLowercase
-			rm.HasUpperCase = e.HasUpperCase
-			rm.HasNumber = e.HasNumber
-			rm.HasSymbol = e.HasSymbol
-		case *ChangedEvent:
-			rm.MinLength = e.MinLength
-			rm.HasLowercase = e.HasLowercase
-			rm.HasUpperCase = e.HasUpperCase
-			rm.HasNumber = e.HasNumber
-			rm.HasSymbol = e.HasSymbol
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/password_complexity/write_model.go

@@ -1,35 +0,0 @@
-package password_complexity
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	MinLength    uint64
-	HasLowercase bool
-	HasUpperCase bool
-	HasNumber    bool
-	HasSymbol    bool
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.MinLength = e.MinLength
-			wm.HasLowercase = e.HasLowercase
-			wm.HasUpperCase = e.HasUpperCase
-			wm.HasNumber = e.HasNumber
-			wm.HasSymbol = e.HasSymbol
-		case *ChangedEvent:
-			wm.MinLength = e.MinLength
-			wm.HasLowercase = e.HasLowercase
-			wm.HasUpperCase = e.HasUpperCase
-			wm.HasNumber = e.HasNumber
-			wm.HasSymbol = e.HasSymbol
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/password_lockout/read_model.go

@@ -1,24 +0,0 @@
-package password_lockout
-
-import "github.com/caos/zitadel/internal/eventstore/v2"
-
-type ReadModel struct {
-	eventstore.ReadModel
-
-	MaxAttempts         uint64
-	ShowLockOutFailures bool
-}
-
-func (rm *ReadModel) Reduce() error {
-	for _, event := range rm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			rm.MaxAttempts = e.MaxAttempts
-			rm.ShowLockOutFailures = e.ShowLockOutFailures
-		case *ChangedEvent:
-			rm.MaxAttempts = e.MaxAttempts
-			rm.ShowLockOutFailures = e.ShowLockOutFailures
-		}
-	}
-	return rm.ReadModel.Reduce()
-}

internal/v2/repository/policy/password_lockout/write_model.go

@@ -1,26 +0,0 @@
-package password_lockout
-
-import (
-	"github.com/caos/zitadel/internal/eventstore/v2"
-)
-
-type WriteModel struct {
-	eventstore.WriteModel
-
-	MaxAttempts         uint64
-	ShowLockOutFailures bool
-}
-
-func (wm *WriteModel) Reduce() error {
-	for _, event := range wm.Events {
-		switch e := event.(type) {
-		case *AddedEvent:
-			wm.MaxAttempts = e.MaxAttempts
-			wm.ShowLockOutFailures = e.ShowLockOutFailures
-		case *ChangedEvent:
-			wm.MaxAttempts = e.MaxAttempts
-			wm.ShowLockOutFailures = e.ShowLockOutFailures
-		}
-	}
-	return wm.WriteModel.Reduce()
-}

internal/v2/repository/policy/policy_login_factors.go

@@ -1,14 +1,15 @@
-package factors
+package policy
 
 import (
 	"encoding/json"
 	"github.com/caos/zitadel/internal/errors"
 	"github.com/caos/zitadel/internal/eventstore/v2"
 	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
 )
 
 const (
-	loginPolicySecondFactorPrefix           = "policy.login.secondfactor."
+	loginPolicySecondFactorPrefix           = loginPolicyPrefix + "secondfactor."
 	LoginPolicySecondFactorAddedEventType   = loginPolicySecondFactorPrefix + "added"
 	LoginPolicySecondFactorRemovedEventType = loginPolicySecondFactorPrefix + "removed"
 
@@ -20,12 +21,12 @@ const (
 type SecondFactorAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
-	MFAType SecondFactorType `json:"mfaType"`
+	MFAType domain.SecondFactorType `json:"mfaType"`
 }
 
 func NewSecondFactorAddedEvent(
 	base *eventstore.BaseEvent,
-	mfaType SecondFactorType,
+	mfaType domain.SecondFactorType,
 ) *SecondFactorAddedEvent {
 	return &SecondFactorAddedEvent{
 		BaseEvent: *base,
@@ -52,12 +53,12 @@ func (e *SecondFactorAddedEvent) Data() interface{} {
 
 type SecondFactorRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
-	MFAType              SecondFactorType `json:"mfaType"`
+	MFAType              domain.SecondFactorType `json:"mfaType"`
 }
 
 func NewSecondFactorRemovedEvent(
 	base *eventstore.BaseEvent,
-	mfaType SecondFactorType,
+	mfaType domain.SecondFactorType,
 ) *SecondFactorRemovedEvent {
 	return &SecondFactorRemovedEvent{
 		BaseEvent: *base,
@@ -85,12 +86,12 @@ func (e *SecondFactorRemovedEvent) Data() interface{} {
 type MultiFactorAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
-	MFAType MultiFactorType `json:"mfaType"`
+	MFAType domain.MultiFactorType `json:"mfaType"`
 }
 
 func NewMultiFactorAddedEvent(
 	base *eventstore.BaseEvent,
-	mfaType MultiFactorType,
+	mfaType domain.MultiFactorType,
 ) *MultiFactorAddedEvent {
 	return &MultiFactorAddedEvent{
 		BaseEvent: *base,
@@ -117,12 +118,12 @@ func (e *MultiFactorAddedEvent) Data() interface{} {
 
 type MultiFactorRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
-	MFAType              MultiFactorType `json:"mfaType"`
+	MFAType              domain.MultiFactorType `json:"mfaType"`
 }
 
 func NewMultiFactorRemovedEvent(
 	base *eventstore.BaseEvent,
-	mfaType MultiFactorType,
+	mfaType domain.MultiFactorType,
 ) *MultiFactorRemovedEvent {
 	return &MultiFactorRemovedEvent{
 		BaseEvent: *base,

internal/v2/repository/policy/policy_login_identity_provider.go

@@ -0,0 +1,85 @@
+package policy
+
+import (
+	"encoding/json"
+	"github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore/v2"
+	"github.com/caos/zitadel/internal/eventstore/v2/repository"
+	"github.com/caos/zitadel/internal/v2/domain"
+)
+
+const (
+	loginPolicyIDPProviderPrevix      = loginPolicyPrefix + "idpprovider."
+	LoginPolicyIDPProviderAddedType   = loginPolicyIDPProviderPrevix + "added"
+	LoginPolicyIDPProviderRemovedType = loginPolicyIDPProviderPrevix + "removed"
+)
+
+type IdentityProviderAddedEvent struct {
+	eventstore.BaseEvent
+
+	IDPConfigID     string                      `json:"idpConfigId"`
+	IDPProviderType domain.IdentityProviderType `json:"idpProviderType"`
+}
+
+func (e *IdentityProviderAddedEvent) Data() interface{} {
+	return e
+}
+
+func NewIdentityProviderAddedEvent(
+	base *eventstore.BaseEvent,
+	idpConfigID string,
+	idpProviderType domain.IdentityProviderType,
+) *IdentityProviderAddedEvent {
+
+	return &IdentityProviderAddedEvent{
+		*base,
+		idpConfigID,
+		idpProviderType,
+	}
+}
+
+func IdentityProviderAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &IdentityProviderAddedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "PROVI-bfNnp", "Errors.Internal")
+	}
+
+	return e, nil
+}
+
+type IdentityProviderRemovedEvent struct {
+	eventstore.BaseEvent
+
+	IDPConfigID string `json:"idpConfigId"`
+}
+
+func (e *IdentityProviderRemovedEvent) Data() interface{} {
+	return e
+}
+
+func NewIdentityProviderRemovedEvent(
+	base *eventstore.BaseEvent,
+	idpConfigID string,
+) *IdentityProviderRemovedEvent {
+	return &IdentityProviderRemovedEvent{
+		BaseEvent:   *base,
+		IDPConfigID: idpConfigID,
+	}
+}
+
+func IdentityProviderRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &IdentityProviderRemovedEvent{
+		BaseEvent: *eventstore.BaseEventFromRepo(event),
+	}
+
+	err := json.Unmarshal(event.Data, e)
+	if err != nil {
+		return nil, errors.ThrowInternal(err, "PROVI-6H0KQ", "Errors.Internal")
+	}
+
+	return e, nil
+}

internal/v2/repository/policy/policy_org_iam.go

@@ -1,4 +1,4 @@
-package org_iam
+package policy
 
 import (
 	"encoding/json"
@@ -12,29 +12,29 @@ const (
 	OrgIAMPolicyChangedEventType = "policy.org.iam.changed"
 )
 
-type AddedEvent struct {
+type OrgIAMPolicyAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	UserLoginMustBeDomain bool `json:"userLoginMustBeDomain"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *OrgIAMPolicyAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewOrgIAMPolicyAddedEvent(
 	base *eventstore.BaseEvent,
 	userLoginMustBeDomain bool,
-) *AddedEvent {
+) *OrgIAMPolicyAddedEvent {
 
-	return &AddedEvent{
+	return &OrgIAMPolicyAddedEvent{
 		BaseEvent:             *base,
 		UserLoginMustBeDomain: userLoginMustBeDomain,
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
+func OrgIAMPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &OrgIAMPolicyAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -46,32 +46,26 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return e, nil
 }
 
-type ChangedEvent struct {
+type OrgIAMPolicyChangedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	UserLoginMustBeDomain bool `json:"userLoginMustBeDomain"`
 }
 
-func (e *ChangedEvent) Data() interface{} {
+func (e *OrgIAMPolicyChangedEvent) Data() interface{} {
 	return e
 }
 
-func NewChangedEvent(
+func NewOrgIAMPolicyChangedEvent(
 	base *eventstore.BaseEvent,
-	current *WriteModel,
-	userLoginMustBeDomain bool,
-) *ChangedEvent {
-	e := &ChangedEvent{
+) *OrgIAMPolicyChangedEvent {
+	return &OrgIAMPolicyChangedEvent{
 		BaseEvent: *base,
 	}
-	if current.UserLoginMustBeDomain != userLoginMustBeDomain {
-		e.UserLoginMustBeDomain = userLoginMustBeDomain
-	}
-	return e
 }
 
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
+func OrgIAMPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &OrgIAMPolicyChangedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 

internal/v2/repository/policy/policy_password_age.go

@@ -1,4 +1,4 @@
-package password_age
+package policy
 
 import (
 	"encoding/json"
@@ -13,32 +13,32 @@ const (
 	PasswordAgePolicyRemovedEventType = "policy.password.age.removed"
 )
 
-type AddedEvent struct {
+type PasswordAgePolicyAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	ExpireWarnDays uint64 `json:"expireWarnDays"`
 	MaxAgeDays     uint64 `json:"maxAgeDays"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *PasswordAgePolicyAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewPasswordAgePolicyAddedEvent(
 	base *eventstore.BaseEvent,
 	expireWarnDays,
 	maxAgeDays uint64,
-) *AddedEvent {
+) *PasswordAgePolicyAddedEvent {
 
-	return &AddedEvent{
+	return &PasswordAgePolicyAddedEvent{
 		BaseEvent:      *base,
 		ExpireWarnDays: expireWarnDays,
 		MaxAgeDays:     maxAgeDays,
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
+func PasswordAgePolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordAgePolicyAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -50,40 +50,27 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return e, nil
 }
 
-type ChangedEvent struct {
+type PasswordAgePolicyChangedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	ExpireWarnDays uint64 `json:"expireWarnDays,omitempty"`
 	MaxAgeDays     uint64 `json:"maxAgeDays,omitempty"`
 }
 
-func (e *ChangedEvent) Data() interface{} {
+func (e *PasswordAgePolicyChangedEvent) Data() interface{} {
 	return e
 }
 
-func NewChangedEvent(
+func NewPasswordAgePolicyChangedEvent(
 	base *eventstore.BaseEvent,
-	current *WriteModel,
-	expireWarnDays,
-	maxAgeDays uint64,
-) *ChangedEvent {
-
-	e := &ChangedEvent{
+) *PasswordAgePolicyChangedEvent {
+	return &PasswordAgePolicyChangedEvent{
 		BaseEvent: *base,
 	}
-
-	if current.ExpireWarnDays != expireWarnDays {
-		e.ExpireWarnDays = expireWarnDays
-	}
-	if current.MaxAgeDays != maxAgeDays {
-		e.MaxAgeDays = maxAgeDays
-	}
-
-	return e
 }
 
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
+func PasswordAgePolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordAgePolicyChangedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -95,24 +82,24 @@ func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error)
 	return e, nil
 }
 
-type RemovedEvent struct {
+type PasswordAgePolicyRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *RemovedEvent) Data() interface{} {
+func (e *PasswordAgePolicyRemovedEvent) Data() interface{} {
 	return nil
 }
 
-func NewRemovedEvent(
+func NewPasswordAgePolicyRemovedEvent(
 	base *eventstore.BaseEvent,
-) *RemovedEvent {
-	return &RemovedEvent{
+) *PasswordAgePolicyRemovedEvent {
+	return &PasswordAgePolicyRemovedEvent{
 		BaseEvent: *base,
 	}
 }
 
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &RemovedEvent{
+func PasswordAgePolicyRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordAgePolicyRemovedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 

internal/v2/repository/policy/policy_password_complexity.go

@@ -1,4 +1,4 @@
-package password_complexity
+package policy
 
 import (
 	"encoding/json"
@@ -13,7 +13,7 @@ const (
 	PasswordComplexityPolicyRemovedEventType = "policy.password.complexity.removed"
 )
 
-type AddedEvent struct {
+type PasswordComplexityPolicyAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	MinLength    uint64 `json:"minLength,omitempty"`
@@ -23,19 +23,19 @@ type AddedEvent struct {
 	HasSymbol    bool   `json:"hasSymbol"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *PasswordComplexityPolicyAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewPasswordComplexityPolicyAddedEvent(
 	base *eventstore.BaseEvent,
 	minLength uint64,
 	hasLowerCase,
 	hasUpperCase,
 	hasNumber,
 	hasSymbol bool,
-) *AddedEvent {
-	return &AddedEvent{
+) *PasswordComplexityPolicyAddedEvent {
+	return &PasswordComplexityPolicyAddedEvent{
 		BaseEvent:    *base,
 		MinLength:    minLength,
 		HasLowercase: hasLowerCase,
@@ -45,8 +45,8 @@ func NewAddedEvent(
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
+func PasswordComplexityPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordComplexityPolicyAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -58,7 +58,7 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return e, nil
 }
 
-type ChangedEvent struct {
+type PasswordComplexityPolicyChangedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	MinLength    uint64 `json:"minLength"`
@@ -68,45 +68,20 @@ type ChangedEvent struct {
 	HasSymbol    bool   `json:"hasSymbol"`
 }
 
-func (e *ChangedEvent) Data() interface{} {
+func (e *PasswordComplexityPolicyChangedEvent) Data() interface{} {
 	return e
 }
 
-func NewChangedEvent(
+func NewPasswordComplexityPolicyChangedEvent(
 	base *eventstore.BaseEvent,
-	current *WriteModel,
-	minLength uint64,
-	hasLowerCase,
-	hasUpperCase,
-	hasNumber,
-	hasSymbol bool,
-) *ChangedEvent {
-
-	e := &ChangedEvent{
+) *PasswordComplexityPolicyChangedEvent {
+	return &PasswordComplexityPolicyChangedEvent{
 		BaseEvent: *base,
 	}
-
-	if current.MinLength != minLength {
-		e.MinLength = minLength
-	}
-	if current.HasLowercase != hasLowerCase {
-		e.HasLowercase = hasLowerCase
-	}
-	if current.HasUpperCase != hasUpperCase {
-		e.HasUpperCase = hasUpperCase
-	}
-	if current.HasNumber != hasNumber {
-		e.HasNumber = hasNumber
-	}
-	if current.HasSymbol != hasSymbol {
-		e.HasSymbol = hasSymbol
-	}
-
-	return e
 }
 
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
+func PasswordComplexityPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordComplexityPolicyChangedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -118,22 +93,22 @@ func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error)
 	return e, nil
 }
 
-type RemovedEvent struct {
+type PasswordComplexityPolicyRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *RemovedEvent) Data() interface{} {
+func (e *PasswordComplexityPolicyRemovedEvent) Data() interface{} {
 	return nil
 }
 
-func NewRemovedEvent(base *eventstore.BaseEvent) *RemovedEvent {
-	return &RemovedEvent{
+func NewPasswordComplexityPolicyRemovedEvent(base *eventstore.BaseEvent) *PasswordComplexityPolicyRemovedEvent {
+	return &PasswordComplexityPolicyRemovedEvent{
 		BaseEvent: *base,
 	}
 }
 
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &RemovedEvent{
+func PasswordComplexityPolicyRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	return &PasswordComplexityPolicyRemovedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}, nil
 }

internal/v2/repository/policy/policy_password_lockout.go

@@ -1,4 +1,4 @@
-package password_lockout
+package policy
 
 import (
 	"encoding/json"
@@ -13,32 +13,32 @@ const (
 	PasswordLockoutPolicyRemovedEventType = "policy.password.lockout.removed"
 )
 
-type AddedEvent struct {
+type PasswordLockoutPolicyAddedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	MaxAttempts         uint64 `json:"maxAttempts,omitempty"`
 	ShowLockOutFailures bool   `json:"showLockOutFailures"`
 }
 
-func (e *AddedEvent) Data() interface{} {
+func (e *PasswordLockoutPolicyAddedEvent) Data() interface{} {
 	return e
 }
 
-func NewAddedEvent(
+func NewPasswordLockoutPolicyAddedEvent(
 	base *eventstore.BaseEvent,
 	maxAttempts uint64,
 	showLockOutFailures bool,
-) *AddedEvent {
+) *PasswordLockoutPolicyAddedEvent {
 
-	return &AddedEvent{
+	return &PasswordLockoutPolicyAddedEvent{
 		BaseEvent:           *base,
 		MaxAttempts:         maxAttempts,
 		ShowLockOutFailures: showLockOutFailures,
 	}
 }
 
-func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &AddedEvent{
+func PasswordLockoutPolicyAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordLockoutPolicyAddedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -50,40 +50,27 @@ func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
 	return e, nil
 }
 
-type ChangedEvent struct {
+type PasswordLockoutPolicyChangedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 
 	MaxAttempts         uint64 `json:"maxAttempts,omitempty"`
 	ShowLockOutFailures bool   `json:"showLockOutFailures,omitempty"`
 }
 
-func (e *ChangedEvent) Data() interface{} {
+func (e *PasswordLockoutPolicyChangedEvent) Data() interface{} {
 	return e
 }
 
-func NewChangedEvent(
+func NewPasswordLockoutPolicyChangedEvent(
 	base *eventstore.BaseEvent,
-	current *WriteModel,
-	maxAttempts uint64,
-	showLockOutFailures bool,
-) *ChangedEvent {
-
-	e := &ChangedEvent{
+) *PasswordLockoutPolicyChangedEvent {
+	return &PasswordLockoutPolicyChangedEvent{
 		BaseEvent: *base,
 	}
-
-	if current.MaxAttempts != maxAttempts {
-		e.MaxAttempts = maxAttempts
-	}
-	if current.ShowLockOutFailures != showLockOutFailures {
-		e.ShowLockOutFailures = showLockOutFailures
-	}
-
-	return e
 }
 
-func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	e := &ChangedEvent{
+func PasswordLockoutPolicyChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	e := &PasswordLockoutPolicyChangedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}
 
@@ -95,25 +82,25 @@ func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error)
 	return e, nil
 }
 
-type RemovedEvent struct {
+type PasswordLockoutPolicyRemovedEvent struct {
 	eventstore.BaseEvent `json:"-"`
 }
 
-func (e *RemovedEvent) Data() interface{} {
+func (e *PasswordLockoutPolicyRemovedEvent) Data() interface{} {
 	return nil
 }
 
-func NewRemovedEvent(
+func NewPasswordLockoutPolicyRemovedEvent(
 	base *eventstore.BaseEvent,
-) *RemovedEvent {
+) *PasswordLockoutPolicyRemovedEvent {
 
-	return &RemovedEvent{
+	return &PasswordLockoutPolicyRemovedEvent{
 		BaseEvent: *base,
 	}
 }
 
-func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
-	return &RemovedEvent{
+func PasswordLockoutPolicyRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
+	return &PasswordLockoutPolicyRemovedEvent{
 		BaseEvent: *eventstore.BaseEventFromRepo(event),
 	}, nil
 }