TheArchive/zitadel
1
0
Fork 0
mirror of https://github.com/zitadel/zitadel.git synced 2025-12-06 15:02:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix(event handling): use internal pubsub for view update (#1118)

Browse Source 
* start sub

* start implement subsciptions

* start subscription

* implementation for member done

* admin done

* fix: tests

* extend handlers

* prepary notification

* no errors in adminapi

* changed current sequence in all packages

* ignore mocks

* works

* subscriptions as singleton

* tests

* refactor: rename function scope var
This commit is contained in:
Silvan
2020-12-18 16:47:45 +01:00
committed by GitHub
parent e15fc0b92b
commit dd5e4acd24
160 changed files with 4010 additions and 1596 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
internal/management/repository/eventsourcing/handler/application.go
View File

@@ -5,7 +5,9 @@ import (
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
"github.com/caos/zitadel/internal/project/repository/eventsourcing"
proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
@@ -13,21 +15,57 @@ import (
view_model "github.com/caos/zitadel/internal/project/repository/view/model"
)
type Application struct {
handler
projectEvents *proj_event.ProjectEventstore
}
const (
applicationTable = "management.applications"
)
type Application struct {
handler
projectEvents *proj_event.ProjectEventstore
subscription *eventstore.Subscription
}
func newApplication(
handler handler,
projectEvents *proj_event.ProjectEventstore,
) *Application {
h := &Application{
handler: handler,
projectEvents: projectEvents,
}
h.subscribe()
return h
}
func (a *Application) subscribe() {
a.subscription = a.es.Subscribe(a.AggregateTypes()...)
go func() {
for event := range a.subscription.Events {
query.ReduceEvent(a, event)
}
}()
}
func (a *Application) ViewModel() string {
return applicationTable
}
func (_ *Application) AggregateTypes() []models.AggregateType {
return []models.AggregateType{es_model.ProjectAggregate}
}
func (a *Application) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := a.view.GetLatestApplicationSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (a *Application) EventQuery() (*models.SearchQuery, error) {
sequence, err := a.view.GetLatestApplicationSequence()
sequence, err := a.view.GetLatestApplicationSequence("")
if err != nil {
return nil, err
}
@@ -65,30 +103,30 @@ func (a *Application) Reduce(event *models.Event) (err error) {
if err != nil {
return err
}
return a.view.DeleteApplication(app.ID, event.Sequence, event.CreationDate)
return a.view.DeleteApplication(app.ID, event)
case es_model.ProjectChanged:
apps, err := a.view.ApplicationsByProjectID(event.AggregateID)
if err != nil {
return err
}
if len(apps) == 0 {
return a.view.ProcessedApplicationSequence(event.Sequence, event.CreationDate)
return a.view.ProcessedApplicationSequence(event)
}
for _, app := range apps {
if err := app.AppendEvent(event); err != nil {
return err
}
}
return a.view.PutApplications(apps, event.Sequence, event.CreationDate)
return a.view.PutApplications(apps, event)
case es_model.ProjectRemoved:
return a.view.DeleteApplicationsByProjectID(event.AggregateID)
default:
return a.view.ProcessedApplicationSequence(event.Sequence, event.CreationDate)
return a.view.ProcessedApplicationSequence(event)
}
if err != nil {
return err
}
return a.view.PutApplication(app, event.CreationDate)
return a.view.PutApplication(app, event)
}
func (a *Application) OnError(event *models.Event, spoolerError error) error {

105
internal/management/repository/eventsourcing/handler/handler.go
View File

@@ -25,6 +25,12 @@ type handler struct {
bulkLimit uint64
cycleDuration time.Duration
errorCountUntilSkip uint64
es eventstore.Eventstore
}
func (h *handler) Eventstore() eventstore.Eventstore {
return h.es
}
type EventstoreRepos struct {
@@ -34,49 +40,76 @@ type EventstoreRepos struct {
IamEvents *iam_event.IAMEventstore
}
func Register(configs Configs, bulkLimit, errorCount uint64, view *view.View, eventstore eventstore.Eventstore, repos EventstoreRepos, defaults systemdefaults.SystemDefaults) []query.Handler {
func Register(configs Configs, bulkLimit, errorCount uint64, view *view.View, es eventstore.Eventstore, repos EventstoreRepos, defaults systemdefaults.SystemDefaults) []query.Handler {
return []query.Handler{
&Project{handler: handler{view, bulkLimit, configs.cycleDuration("Project"), errorCount},
eventstore: eventstore},
&ProjectGrant{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectGrant"), errorCount},
eventstore: eventstore, projectEvents: repos.ProjectEvents, orgEvents: repos.OrgEvents},
&ProjectRole{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectRole"), errorCount},
projectEvents: repos.ProjectEvents},
&ProjectMember{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectMember"), errorCount},
userEvents: repos.UserEvents},
&ProjectGrantMember{handler: handler{view, bulkLimit, configs.cycleDuration("ProjectGrantMember"), errorCount},
userEvents: repos.UserEvents},
&Application{handler: handler{view, bulkLimit, configs.cycleDuration("Application"), errorCount},
projectEvents: repos.ProjectEvents},
&User{handler: handler{view, bulkLimit, configs.cycleDuration("User"), errorCount},
eventstore: eventstore, orgEvents: repos.OrgEvents, iamEvents: repos.IamEvents, iamID: defaults.IamID},
&UserGrant{handler: handler{view, bulkLimit, configs.cycleDuration("UserGrant"), errorCount},
projectEvents: repos.ProjectEvents, userEvents: repos.UserEvents, orgEvents: repos.OrgEvents},
&Org{handler: handler{view, bulkLimit, configs.cycleDuration("Org"), errorCount}},
&OrgMember{handler: handler{view, bulkLimit, configs.cycleDuration("OrgMember"), errorCount},
userEvents: repos.UserEvents},
&OrgDomain{handler: handler{view, bulkLimit, configs.cycleDuration("OrgDomain"), errorCount}},
&UserMembership{handler: handler{view, bulkLimit, configs.cycleDuration("UserMembership"), errorCount},
orgEvents: repos.OrgEvents, projectEvents: repos.ProjectEvents},
&MachineKeys{handler: handler{view, bulkLimit, configs.cycleDuration("MachineKeys"), errorCount}},
&IDPConfig{handler: handler{view, bulkLimit, configs.cycleDuration("IDPConfig"), errorCount}},
&LoginPolicy{handler: handler{view, bulkLimit, configs.cycleDuration("LoginPolicy"), errorCount}},
&LabelPolicy{handler: handler{view, bulkLimit, configs.cycleDuration("LabelPolicy"), errorCount}},
&IDPProvider{handler: handler{view, bulkLimit, configs.cycleDuration("IDPProvider"), errorCount},
systemDefaults: defaults, iamEvents: repos.IamEvents, orgEvents: repos.OrgEvents},
&ExternalIDP{handler: handler{view, bulkLimit, configs.cycleDuration("ExternalIDP"), errorCount},
systemDefaults: defaults, iamEvents: repos.IamEvents, orgEvents: repos.OrgEvents},
&PasswordComplexityPolicy{handler: handler{view, bulkLimit, configs.cycleDuration("PasswordComplexityPolicy"), errorCount}},
&PasswordAgePolicy{handler: handler{view, bulkLimit, configs.cycleDuration("PasswordAgePolicy"), errorCount}},
&PasswordLockoutPolicy{handler: handler{view, bulkLimit, configs.cycleDuration("PasswordLockoutPolicy"), errorCount}},
&OrgIAMPolicy{handler: handler{view, bulkLimit, configs.cycleDuration("OrgIAMPolicy"), errorCount}},
newProject(
handler{view, bulkLimit, configs.cycleDuration("Project"), errorCount, es}),
newProjectGrant(
handler{view, bulkLimit, configs.cycleDuration("ProjectGrant"), errorCount, es},
repos.ProjectEvents,
repos.OrgEvents),
newProjectRole(handler{view, bulkLimit, configs.cycleDuration("ProjectRole"), errorCount, es},
repos.ProjectEvents),
newProjectMember(handler{view, bulkLimit, configs.cycleDuration("ProjectMember"), errorCount, es},
repos.UserEvents),
newProjectGrantMember(handler{view, bulkLimit, configs.cycleDuration("ProjectGrantMember"), errorCount, es},
repos.UserEvents),
newApplication(handler{view, bulkLimit, configs.cycleDuration("Application"), errorCount, es},
repos.ProjectEvents),
newUser(handler{view, bulkLimit, configs.cycleDuration("User"), errorCount, es},
repos.OrgEvents,
repos.IamEvents,
defaults.IamID),
newUserGrant(handler{view, bulkLimit, configs.cycleDuration("UserGrant"), errorCount, es},
repos.ProjectEvents,
repos.UserEvents,
repos.OrgEvents),
newOrg(
handler{view, bulkLimit, configs.cycleDuration("Org"), errorCount, es}),
newOrgMember(
handler{view, bulkLimit, configs.cycleDuration("OrgMember"), errorCount, es},
repos.UserEvents),
newOrgDomain(
handler{view, bulkLimit, configs.cycleDuration("OrgDomain"), errorCount, es}),
newUserMembership(
handler{view, bulkLimit, configs.cycleDuration("UserMembership"), errorCount, es},
repos.OrgEvents,
repos.ProjectEvents),
newMachineKeys(
handler{view, bulkLimit, configs.cycleDuration("MachineKeys"), errorCount, es}),
newIDPConfig(
handler{view, bulkLimit, configs.cycleDuration("IDPConfig"), errorCount, es}),
newLoginPolicy(
handler{view, bulkLimit, configs.cycleDuration("LoginPolicy"), errorCount, es}),
newLabelPolicy(
handler{view, bulkLimit, configs.cycleDuration("LabelPolicy"), errorCount, es}),
newIDPProvider(
handler{view, bulkLimit, configs.cycleDuration("IDPProvider"), errorCount, es},
defaults,
repos.IamEvents,
repos.OrgEvents),
newExternalIDP(
handler{view, bulkLimit, configs.cycleDuration("ExternalIDP"), errorCount, es},
defaults,
repos.IamEvents,
repos.OrgEvents),
newPasswordComplexityPolicy(
handler{view, bulkLimit, configs.cycleDuration("PasswordComplexityPolicy"), errorCount, es}),
newPasswordAgePolicy(
handler{view, bulkLimit, configs.cycleDuration("PasswordAgePolicy"), errorCount, es}),
newPasswordLockoutPolicy(
handler{view, bulkLimit, configs.cycleDuration("PasswordLockoutPolicy"), errorCount, es}),
newOrgIAMPolicy(
handler{view, bulkLimit, configs.cycleDuration("OrgIAMPolicy"), errorCount, es}),
}
}
func (configs Configs) cycleDuration(viewModel string) time.Duration {
c, ok := configs[viewModel]
if !ok {
return 1 * time.Second
return 3 * time.Minute
}
return c.MinimumCycleDuration.Duration
}

60
internal/management/repository/eventsourcing/handler/idp_config.go
View File

@@ -2,8 +2,10 @@ package handler
import (
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_model "github.com/caos/zitadel/internal/iam/model"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
@@ -11,29 +13,61 @@ import (
"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
)
type IDPConfig struct {
handler
}
const (
idpConfigTable = "management.idp_configs"
)
type IDPConfig struct {
handler
subscription *eventstore.Subscription
}
func newIDPConfig(handler handler) *IDPConfig {
h := &IDPConfig{
handler: handler,
}
h.subscribe()
return h
}
func (m *IDPConfig) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (m *IDPConfig) ViewModel() string {
return idpConfigTable
}
func (m *IDPConfig) EventQuery() (*models.SearchQuery, error) {
sequence, err := m.view.GetLatestIDPConfigSequence()
func (_ *IDPConfig) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
}
func (m *IDPConfig) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := m.view.GetLatestIDPConfigSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (m *IDPConfig) EventQuery() (*es_models.SearchQuery, error) {
sequence, err := m.view.GetLatestIDPConfigSequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
AggregateTypeFilter(m.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
func (m *IDPConfig) Reduce(event *models.Event) (err error) {
func (m *IDPConfig) Reduce(event *es_models.Event) (err error) {
switch event.AggregateType {
case model.OrgAggregate:
err = m.processIdpConfig(iam_model.IDPProviderTypeOrg, event)
@@ -43,7 +77,7 @@ func (m *IDPConfig) Reduce(event *models.Event) (err error) {
return err
}
func (m *IDPConfig) processIdpConfig(providerType iam_model.IDPProviderType, event *models.Event) (err error) {
func (m *IDPConfig) processIdpConfig(providerType iam_model.IDPProviderType, event *es_models.Event) (err error) {
idp := new(iam_view_model.IDPConfigView)
switch event.Type {
case model.IDPConfigAdded,
@@ -66,17 +100,17 @@ func (m *IDPConfig) processIdpConfig(providerType iam_model.IDPProviderType, eve
if err != nil {
return err
}
return m.view.DeleteIDPConfig(idp.IDPConfigID, event.Sequence, event.CreationDate)
return m.view.DeleteIDPConfig(idp.IDPConfigID, event)
default:
return m.view.ProcessedIDPConfigSequence(event.Sequence, event.CreationDate)
return m.view.ProcessedIDPConfigSequence(event)
}
if err != nil {
return err
}
return m.view.PutIDPConfig(idp, idp.Sequence, event.CreationDate)
return m.view.PutIDPConfig(idp, event)
}
func (i *IDPConfig) OnError(event *models.Event, err error) error {
func (i *IDPConfig) OnError(event *es_models.Event, err error) error {
logging.LogWithFields("SPOOL-Nxu8s", "id", event.AggregateID).WithError(err).Warn("something went wrong in idp config handler")
return spooler.HandleError(event, err, i.view.GetLatestIDPConfigFailedEvent, i.view.ProcessedIDPConfigFailedEvent, i.view.ProcessedIDPConfigSequence, i.errorCountUntilSkip)
}

79
internal/management/repository/eventsourcing/handler/idp_providers.go
View File

@@ -2,18 +2,23 @@ package handler
import (
"context"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/config/systemdefaults"
"github.com/caos/zitadel/internal/iam/repository/eventsourcing"
org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
"github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_model "github.com/caos/zitadel/internal/iam/model"
"github.com/caos/zitadel/internal/iam/repository/eventsourcing"
"github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
iam_view_model "github.com/caos/zitadel/internal/iam/repository/view/model"
org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
)
const (
idpProviderTable = "management.idp_providers"
)
type IDPProvider struct {
@@ -21,27 +26,63 @@ type IDPProvider struct {
systemDefaults systemdefaults.SystemDefaults
iamEvents *eventsourcing.IAMEventstore
orgEvents *org_es.OrgEventstore
subscription *eventstore.Subscription
}
const (
idpProviderTable = "management.idp_providers"
)
func newIDPProvider(
handler handler,
systemDefaults systemdefaults.SystemDefaults,
iamEvents *eventsourcing.IAMEventstore,
orgEvents *org_es.OrgEventstore,
) *IDPProvider {
h := &IDPProvider{
handler: handler,
systemDefaults: systemDefaults,
iamEvents: iamEvents,
orgEvents: orgEvents,
}
h.subscribe()
return h
}
func (m *IDPProvider) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (m *IDPProvider) ViewModel() string {
return idpProviderTable
}
func (m *IDPProvider) EventQuery() (*models.SearchQuery, error) {
sequence, err := m.view.GetLatestIDPProviderSequence()
func (_ *IDPProvider) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.IAMAggregate, org_es_model.OrgAggregate}
}
func (m *IDPProvider) CurrentSequence(event *es_models.Event) (uint64, error) {
sequence, err := m.view.GetLatestIDPProviderSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (m *IDPProvider) EventQuery() (*es_models.SearchQuery, error) {
sequence, err := m.view.GetLatestIDPProviderSequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.IAMAggregate, org_es_model.OrgAggregate).
AggregateTypeFilter(m.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
func (m *IDPProvider) Reduce(event *models.Event) (err error) {
func (m *IDPProvider) Reduce(event *es_models.Event) (err error) {
switch event.AggregateType {
case model.IAMAggregate, org_es_model.OrgAggregate:
err = m.processIdpProvider(event)
@@ -49,7 +90,7 @@ func (m *IDPProvider) Reduce(event *models.Event) (err error) {
return err
}
func (m *IDPProvider) processIdpProvider(event *models.Event) (err error) {
func (m *IDPProvider) processIdpProvider(event *es_models.Event) (err error) {
provider := new(iam_view_model.IDPProviderView)
switch event.Type {
case model.LoginPolicyIDPProviderAdded, org_es_model.LoginPolicyIDPProviderAdded:
@@ -64,7 +105,7 @@ func (m *IDPProvider) processIdpProvider(event *models.Event) (err error) {
if err != nil {
return err
}
return m.view.DeleteIDPProvider(event.AggregateID, provider.IDPConfigID, event.Sequence, event.CreationDate)
return m.view.DeleteIDPProvider(event.AggregateID, provider.IDPConfigID, event)
case model.IDPConfigChanged, org_es_model.IDPConfigChanged:
esConfig := new(iam_view_model.IDPConfigView)
providerType := iam_model.IDPProviderTypeSystem
@@ -88,16 +129,16 @@ func (m *IDPProvider) processIdpProvider(event *models.Event) (err error) {
for _, provider := range providers {
m.fillConfigData(provider, config)
}
return m.view.PutIDPProviders(event.Sequence, event.CreationDate, providers...)
return m.view.PutIDPProviders(event, providers...)
case org_es_model.LoginPolicyRemoved:
return m.view.DeleteIDPProvidersByAggregateID(event.AggregateID, event.Sequence, event.CreationDate)
return m.view.DeleteIDPProvidersByAggregateID(event.AggregateID, event)
default:
return m.view.ProcessedIDPProviderSequence(event.Sequence, event.CreationDate)
return m.view.ProcessedIDPProviderSequence(event)
}
if err != nil {
return err
}
return m.view.PutIDPProvider(provider, provider.Sequence, event.CreationDate)
return m.view.PutIDPProvider(provider, event)
}
func (m *IDPProvider) fillData(provider *iam_view_model.IDPProviderView) (err error) {
@@ -121,7 +162,7 @@ func (m *IDPProvider) fillConfigData(provider *iam_view_model.IDPProviderView, c
provider.IDPState = int32(config.State)
}
func (m *IDPProvider) OnError(event *models.Event, err error) error {
func (m *IDPProvider) OnError(event *es_models.Event, err error) error {
logging.LogWithFields("SPOOL-Msj8c", "id", event.AggregateID).WithError(err).Warn("something went wrong in idp provider handler")
return spooler.HandleError(event, err, m.view.GetLatestIDPProviderFailedEvent, m.view.ProcessedIDPProviderFailedEvent, m.view.ProcessedIDPProviderSequence, m.errorCountUntilSkip)
}

53
internal/management/repository/eventsourcing/handler/label_policy.go
View File

@@ -2,34 +2,67 @@ package handler
import (
"github.com/caos/logging"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
)
type LabelPolicy struct {
handler
}
const (
labelPolicyTable = "management.label_policies"
)
type LabelPolicy struct {
handler
subscription *eventstore.Subscription
}
func newLabelPolicy(handler handler) *LabelPolicy {
h := &LabelPolicy{
handler: handler,
}
h.subscribe()
return h
}
func (m *LabelPolicy) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (m *LabelPolicy) ViewModel() string {
return labelPolicyTable
}
func (_ *LabelPolicy) AggregateTypes() []models.AggregateType {
return []models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
}
func (m *LabelPolicy) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := m.view.GetLatestLabelPolicySequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (m *LabelPolicy) EventQuery() (*models.SearchQuery, error) {
sequence, err := m.view.GetLatestLabelPolicySequence()
sequence, err := m.view.GetLatestLabelPolicySequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
AggregateTypeFilter(m.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -53,12 +86,12 @@ func (m *LabelPolicy) processLabelPolicy(event *models.Event) (err error) {
}
err = policy.AppendEvent(event)
default:
return m.view.ProcessedLabelPolicySequence(event.Sequence, event.CreationDate)
return m.view.ProcessedLabelPolicySequence(event)
}
if err != nil {
return err
}
return m.view.PutLabelPolicy(policy, policy.Sequence, event.CreationDate)
return m.view.PutLabelPolicy(policy, event)
}
func (m *LabelPolicy) OnError(event *models.Event, err error) error {

55
internal/management/repository/eventsourcing/handler/login_policy.go
View File

@@ -2,34 +2,67 @@ package handler
import (
"github.com/caos/logging"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
)
type LoginPolicy struct {
handler
}
const (
loginPolicyTable = "management.login_policies"
)
type LoginPolicy struct {
handler
subscription *eventstore.Subscription
}
func newLoginPolicy(handler handler) *LoginPolicy {
h := &LoginPolicy{
handler: handler,
}
h.subscribe()
return h
}
func (m *LoginPolicy) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (m *LoginPolicy) ViewModel() string {
return loginPolicyTable
}
func (_ *LoginPolicy) AggregateTypes() []models.AggregateType {
return []models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
}
func (m *LoginPolicy) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := m.view.GetLatestLoginPolicySequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (m *LoginPolicy) EventQuery() (*models.SearchQuery, error) {
sequence, err := m.view.GetLatestLoginPolicySequence()
sequence, err := m.view.GetLatestLoginPolicySequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
AggregateTypeFilter(m.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -57,14 +90,14 @@ func (m *LoginPolicy) processLoginPolicy(event *models.Event) (err error) {
}
err = policy.AppendEvent(event)
case model.LoginPolicyRemoved:
return m.view.DeleteLoginPolicy(event.AggregateID, event.Sequence, event.CreationDate)
return m.view.DeleteLoginPolicy(event.AggregateID, event)
default:
return m.view.ProcessedLoginPolicySequence(event.Sequence, event.CreationDate)
return m.view.ProcessedLoginPolicySequence(event)
}
if err != nil {
return err
}
return m.view.PutLoginPolicy(policy, policy.Sequence, event.CreationDate)
return m.view.PutLoginPolicy(policy, event)
}
func (m *LoginPolicy) OnError(event *models.Event, err error) error {

57
internal/management/repository/eventsourcing/handler/machine_keys.go
View File

@@ -4,33 +4,66 @@ import (
"time"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
"github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
usr_model "github.com/caos/zitadel/internal/user/repository/view/model"
)
type MachineKeys struct {
handler
}
const (
machineKeysTable = "management.machine_keys"
)
type MachineKeys struct {
handler
subscription *eventstore.Subscription
}
func newMachineKeys(handler handler) *MachineKeys {
h := &MachineKeys{
handler: handler,
}
h.subscribe()
return h
}
func (m *MachineKeys) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (d *MachineKeys) ViewModel() string {
return machineKeysTable
}
func (_ *MachineKeys) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.UserAggregate}
}
func (k *MachineKeys) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := k.view.GetLatestMachineKeySequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (d *MachineKeys) EventQuery() (*models.SearchQuery, error) {
sequence, err := d.view.GetLatestMachineKeySequence()
sequence, err := d.view.GetLatestMachineKeySequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.UserAggregate).
AggregateTypeFilter(d.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -48,23 +81,23 @@ func (d *MachineKeys) processMachineKeys(event *models.Event) (err error) {
case model.MachineKeyAdded:
err = key.AppendEvent(event)
if key.ExpirationDate.Before(time.Now()) {
return d.view.ProcessedMachineKeySequence(event.Sequence, event.CreationDate)
return d.view.ProcessedMachineKeySequence(event)
}
case model.MachineKeyRemoved:
err = key.SetData(event)
if err != nil {
return err
}
return d.view.DeleteMachineKey(key.ID, event.Sequence, event.CreationDate)
return d.view.DeleteMachineKey(key.ID, event)
case model.UserRemoved:
return d.view.DeleteMachineKeysByUserID(event.AggregateID, event.Sequence, event.CreationDate)
return d.view.DeleteMachineKeysByUserID(event.AggregateID, event)
default:
return d.view.ProcessedMachineKeySequence(event.Sequence, event.CreationDate)
return d.view.ProcessedMachineKeySequence(event)
}
if err != nil {
return err
}
return d.view.PutMachineKey(key, key.Sequence, event.CreationDate)
return d.view.PutMachineKey(key, event)
}
func (d *MachineKeys) OnError(event *models.Event, err error) error {

50
internal/management/repository/eventsourcing/handler/org.go
View File

@@ -2,28 +2,62 @@ package handler
import (
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
"github.com/caos/zitadel/internal/org/repository/eventsourcing"
"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
org_model "github.com/caos/zitadel/internal/org/repository/view/model"
)
type Org struct {
handler
}
const (
orgTable = "management.orgs"
)
type Org struct {
handler
subscription *eventstore.Subscription
}
func newOrg(handler handler) *Org {
h := &Org{
handler: handler,
}
h.subscribe()
return h
}
func (m *Org) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (o *Org) ViewModel() string {
return orgTable
}
func (_ *Org) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.OrgAggregate}
}
func (o *Org) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := o.view.GetLatestOrgSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (o *Org) EventQuery() (*es_models.SearchQuery, error) {
sequence, err := o.view.GetLatestOrgSequence()
sequence, err := o.view.GetLatestOrgSequence("")
if err != nil {
return nil, err
}
@@ -47,12 +81,12 @@ func (o *Org) Reduce(event *es_models.Event) (err error) {
}
err = org.AppendEvent(event)
default:
return o.view.ProcessedOrgSequence(event.Sequence, event.CreationDate)
return o.view.ProcessedOrgSequence(event)
}
if err != nil {
return err
}
return o.view.PutOrg(org, event.CreationDate)
return o.view.PutOrg(org, event)
}
func (o *Org) OnError(event *es_models.Event, spoolerErr error) error {

55
internal/management/repository/eventsourcing/handler/org_domain.go
View File

@@ -2,33 +2,66 @@ package handler
import (
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
org_model "github.com/caos/zitadel/internal/org/repository/view/model"
)
type OrgDomain struct {
handler
}
const (
orgDomainTable = "management.org_domains"
)
type OrgDomain struct {
handler
subscription *eventstore.Subscription
}
func newOrgDomain(handler handler) *OrgDomain {
h := &OrgDomain{
handler: handler,
}
h.subscribe()
return h
}
func (m *OrgDomain) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (d *OrgDomain) ViewModel() string {
return orgDomainTable
}
func (_ *OrgDomain) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.OrgAggregate}
}
func (p *OrgDomain) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := p.view.GetLatestOrgDomainSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (d *OrgDomain) EventQuery() (*models.SearchQuery, error) {
sequence, err := d.view.GetLatestOrgDomainSequence()
sequence, err := d.view.GetLatestOrgDomainSequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.OrgAggregate).
AggregateTypeFilter(d.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -72,7 +105,7 @@ func (d *OrgDomain) processOrgDomain(event *models.Event) (err error) {
for _, existingDomain := range existingDomains {
existingDomain.Primary = false
}
err = d.view.PutOrgDomains(existingDomains, 0, event.CreationDate)
err = d.view.PutOrgDomains(existingDomains, event)
if err != nil {
return err
}
@@ -82,14 +115,14 @@ func (d *OrgDomain) processOrgDomain(event *models.Event) (err error) {
if err != nil {
return err
}
return d.view.DeleteOrgDomain(event.AggregateID, domain.Domain, event.Sequence, event.CreationDate)
return d.view.DeleteOrgDomain(event.AggregateID, domain.Domain, event)
default:
return d.view.ProcessedOrgDomainSequence(event.Sequence, event.CreationDate)
return d.view.ProcessedOrgDomainSequence(event)
}
if err != nil {
return err
}
return d.view.PutOrgDomain(domain, domain.Sequence, event.CreationDate)
return d.view.PutOrgDomain(domain, event)
}
func (d *OrgDomain) OnError(event *models.Event, err error) error {

55
internal/management/repository/eventsourcing/handler/org_iam_policy.go
View File

@@ -2,34 +2,67 @@ package handler
import (
"github.com/caos/logging"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
)
type OrgIAMPolicy struct {
handler
}
const (
orgIAMPolicyTable = "management.org_iam_policies"
)
type OrgIAMPolicy struct {
handler
subscription *eventstore.Subscription
}
func newOrgIAMPolicy(handler handler) *OrgIAMPolicy {
h := &OrgIAMPolicy{
handler: handler,
}
h.subscribe()
return h
}
func (m *OrgIAMPolicy) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (m *OrgIAMPolicy) ViewModel() string {
return orgIAMPolicyTable
}
func (_ *OrgIAMPolicy) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
}
func (p *OrgIAMPolicy) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := p.view.GetLatestOrgIAMPolicySequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (m *OrgIAMPolicy) EventQuery() (*models.SearchQuery, error) {
sequence, err := m.view.GetLatestOrgIAMPolicySequence()
sequence, err := m.view.GetLatestOrgIAMPolicySequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
AggregateTypeFilter(m.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -53,14 +86,14 @@ func (m *OrgIAMPolicy) processOrgIAMPolicy(event *models.Event) (err error) {
}
err = policy.AppendEvent(event)
case model.OrgIAMPolicyRemoved:
return m.view.DeleteOrgIAMPolicy(event.AggregateID, event.Sequence, event.CreationDate)
return m.view.DeleteOrgIAMPolicy(event.AggregateID, event)
default:
return m.view.ProcessedOrgIAMPolicySequence(event.Sequence, event.CreationDate)
return m.view.ProcessedOrgIAMPolicySequence(event)
}
if err != nil {
return err
}
return m.view.PutOrgIAMPolicy(policy, policy.Sequence, event.CreationDate)
return m.view.PutOrgIAMPolicy(policy, event)
}
func (m *OrgIAMPolicy) OnError(event *models.Event, err error) error {

68
internal/management/repository/eventsourcing/handler/org_member.go
View File

@@ -4,9 +4,10 @@ import (
"context"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
org_model "github.com/caos/zitadel/internal/org/repository/view/model"
@@ -15,26 +16,62 @@ import (
usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
)
type OrgMember struct {
handler
userEvents *usr_event.UserEventstore
}
const (
orgMemberTable = "management.org_members"
)
type OrgMember struct {
handler
userEvents *usr_event.UserEventstore
subscription *eventstore.Subscription
}
func newOrgMember(
handler handler,
userEvents *usr_event.UserEventstore,
) *OrgMember {
h := &OrgMember{
handler: handler,
userEvents: userEvents,
}
h.subscribe()
return h
}
func (m *OrgMember) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (m *OrgMember) ViewModel() string {
return orgMemberTable
}
func (_ *OrgMember) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.OrgAggregate, usr_es_model.UserAggregate}
}
func (p *OrgMember) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := p.view.GetLatestOrgMemberSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (m *OrgMember) EventQuery() (*models.SearchQuery, error) {
sequence, err := m.view.GetLatestOrgMemberSequence()
sequence, err := m.view.GetLatestOrgMemberSequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.OrgAggregate, usr_es_model.UserAggregate).
AggregateTypeFilter(m.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -72,14 +109,14 @@ func (m *OrgMember) processOrgMember(event *models.Event) (err error) {
if err != nil {
return err
}
return m.view.DeleteOrgMember(event.AggregateID, member.UserID, event.Sequence, event.CreationDate)
return m.view.DeleteOrgMember(event.AggregateID, member.UserID, event)
default:
return m.view.ProcessedOrgMemberSequence(event.Sequence, event.CreationDate)
return m.view.ProcessedOrgMemberSequence(event)
}
if err != nil {
return err
}
return m.view.PutOrgMember(member, member.Sequence, event.CreationDate)
return m.view.PutOrgMember(member, event)
}
func (m *OrgMember) processUser(event *models.Event) (err error) {
@@ -94,7 +131,7 @@ func (m *OrgMember) processUser(event *models.Event) (err error) {
return err
}
if len(members) == 0 {
return m.view.ProcessedOrgMemberSequence(event.Sequence, event.CreationDate)
return m.view.ProcessedOrgMemberSequence(event)
}
user, err := m.userEvents.UserByID(context.Background(), event.AggregateID)
if err != nil {
@@ -103,13 +140,12 @@ func (m *OrgMember) processUser(event *models.Event) (err error) {
for _, member := range members {
m.fillUserData(member, user)
}
return m.view.PutOrgMembers(members, event.Sequence, event.CreationDate)
return m.view.PutOrgMembers(members, event)
case usr_es_model.UserRemoved:
return m.view.DeleteOrgMembersByUserID(event.AggregateID, event.Sequence, event.CreationDate)
return m.view.DeleteOrgMembersByUserID(event.AggregateID, event)
default:
return m.view.ProcessedOrgMemberSequence(event.Sequence, event.CreationDate)
return m.view.ProcessedOrgMemberSequence(event)
}
return nil
}
func (m *OrgMember) fillData(member *org_model.OrgMemberView) (err error) {

57
internal/management/repository/eventsourcing/handler/password_age_policy.go
View File

@@ -2,34 +2,67 @@ package handler
import (
"github.com/caos/logging"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
)
type PasswordAgePolicy struct {
handler
}
const (
passwordAgePolicyTable = "management.password_age_policies"
)
type PasswordAgePolicy struct {
handler
subscription *eventstore.Subscription
}
func newPasswordAgePolicy(handler handler) *PasswordAgePolicy {
h := &PasswordAgePolicy{
handler: handler,
}
h.subscribe()
return h
}
func (m *PasswordAgePolicy) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (m *PasswordAgePolicy) ViewModel() string {
return passwordAgePolicyTable
}
func (m *PasswordAgePolicy) EventQuery() (*models.SearchQuery, error) {
sequence, err := m.view.GetLatestPasswordAgePolicySequence()
func (_ *PasswordAgePolicy) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
}
func (o *PasswordAgePolicy) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := o.view.GetLatestPasswordAgePolicySequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (p *PasswordAgePolicy) EventQuery() (*models.SearchQuery, error) {
sequence, err := p.view.GetLatestPasswordAgePolicySequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
AggregateTypeFilter(p.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -53,14 +86,14 @@ func (m *PasswordAgePolicy) processPasswordAgePolicy(event *models.Event) (err e
}
err = policy.AppendEvent(event)
case model.PasswordAgePolicyRemoved:
return m.view.DeletePasswordAgePolicy(event.AggregateID, event.Sequence, event.CreationDate)
return m.view.DeletePasswordAgePolicy(event.AggregateID, event)
default:
return m.view.ProcessedPasswordAgePolicySequence(event.Sequence, event.CreationDate)
return m.view.ProcessedPasswordAgePolicySequence(event)
}
if err != nil {
return err
}
return m.view.PutPasswordAgePolicy(policy, policy.Sequence, event.CreationDate)
return m.view.PutPasswordAgePolicy(policy, event)
}
func (m *PasswordAgePolicy) OnError(event *models.Event, err error) error {

55
internal/management/repository/eventsourcing/handler/password_complexity_policy.go
View File

@@ -2,34 +2,67 @@ package handler
import (
"github.com/caos/logging"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
)
type PasswordComplexityPolicy struct {
handler
}
const (
passwordComplexityPolicyTable = "management.password_complexity_policies"
)
type PasswordComplexityPolicy struct {
handler
subscription *eventstore.Subscription
}
func newPasswordComplexityPolicy(handler handler) *PasswordComplexityPolicy {
h := &PasswordComplexityPolicy{
handler: handler,
}
h.subscribe()
return h
}
func (m *PasswordComplexityPolicy) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (p *PasswordComplexityPolicy) ViewModel() string {
return passwordComplexityPolicyTable
}
func (_ *PasswordComplexityPolicy) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
}
func (p *PasswordComplexityPolicy) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := p.view.GetLatestPasswordComplexityPolicySequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (p *PasswordComplexityPolicy) EventQuery() (*models.SearchQuery, error) {
sequence, err := p.view.GetLatestPasswordComplexityPolicySequence()
sequence, err := p.view.GetLatestPasswordComplexityPolicySequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
AggregateTypeFilter(p.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -53,14 +86,14 @@ func (p *PasswordComplexityPolicy) processPasswordComplexityPolicy(event *models
}
err = policy.AppendEvent(event)
case model.PasswordComplexityPolicyRemoved:
return p.view.DeletePasswordComplexityPolicy(event.AggregateID, event.Sequence, event.CreationDate)
return p.view.DeletePasswordComplexityPolicy(event.AggregateID, event)
default:
return p.view.ProcessedPasswordComplexityPolicySequence(event.Sequence, event.CreationDate)
return p.view.ProcessedPasswordComplexityPolicySequence(event)
}
if err != nil {
return err
}
return p.view.PutPasswordComplexityPolicy(policy, policy.Sequence, event.CreationDate)
return p.view.PutPasswordComplexityPolicy(policy, event)
}
func (p *PasswordComplexityPolicy) OnError(event *models.Event, err error) error {

52
internal/management/repository/eventsourcing/handler/password_lockout_policy.go
View File

@@ -2,34 +2,68 @@ package handler
import (
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_model "github.com/caos/zitadel/internal/iam/repository/view/model"
"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
)
type PasswordLockoutPolicy struct {
handler
}
const (
passwordLockoutPolicyTable = "management.password_lockout_policies"
)
type PasswordLockoutPolicy struct {
handler
subscription *eventstore.Subscription
}
func newPasswordLockoutPolicy(handler handler) *PasswordLockoutPolicy {
h := &PasswordLockoutPolicy{
handler: handler,
}
h.subscribe()
return h
}
func (m *PasswordLockoutPolicy) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (p *PasswordLockoutPolicy) ViewModel() string {
return passwordLockoutPolicyTable
}
func (_ *PasswordLockoutPolicy) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.OrgAggregate, iam_es_model.IAMAggregate}
}
func (p *PasswordLockoutPolicy) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := p.view.GetLatestPasswordLockoutPolicySequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (p *PasswordLockoutPolicy) EventQuery() (*models.SearchQuery, error) {
sequence, err := p.view.GetLatestPasswordLockoutPolicySequence()
sequence, err := p.view.GetLatestPasswordLockoutPolicySequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.OrgAggregate, iam_es_model.IAMAggregate).
AggregateTypeFilter(p.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -53,14 +87,14 @@ func (p *PasswordLockoutPolicy) processPasswordLockoutPolicy(event *models.Event
}
err = policy.AppendEvent(event)
case model.PasswordLockoutPolicyRemoved:
return p.view.DeletePasswordLockoutPolicy(event.AggregateID, event.Sequence, event.CreationDate)
return p.view.DeletePasswordLockoutPolicy(event.AggregateID, event)
default:
return p.view.ProcessedPasswordLockoutPolicySequence(event.Sequence, event.CreationDate)
return p.view.ProcessedPasswordLockoutPolicySequence(event)
}
if err != nil {
return err
}
return p.view.PutPasswordLockoutPolicy(policy, policy.Sequence, event.CreationDate)
return p.view.PutPasswordLockoutPolicy(policy, event)
}
func (p *PasswordLockoutPolicy) OnError(event *models.Event, err error) error {

50
internal/management/repository/eventsourcing/handler/project.go
View File

@@ -5,27 +5,59 @@ import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
view_model "github.com/caos/zitadel/internal/project/repository/view/model"
)
type Project struct {
handler
eventstore eventstore.Eventstore
}
const (
projectTable = "management.projects"
)
type Project struct {
handler
subscription *eventstore.Subscription
}
func newProject(handler handler) *Project {
h := &Project{
handler: handler,
}
h.subscribe()
return h
}
func (m *Project) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (p *Project) ViewModel() string {
return projectTable
}
func (_ *Project) AggregateTypes() []models.AggregateType {
return []models.AggregateType{es_model.ProjectAggregate}
}
func (p *Project) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := p.view.GetLatestProjectSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (p *Project) EventQuery() (*models.SearchQuery, error) {
sequence, err := p.view.GetLatestProjectSequence()
sequence, err := p.view.GetLatestProjectSequence("")
if err != nil {
return nil, err
}
@@ -46,14 +78,14 @@ func (p *Project) Reduce(event *models.Event) (err error) {
}
err = project.AppendEvent(event)
case es_model.ProjectRemoved:
return p.view.DeleteProject(event.AggregateID, event.Sequence, event.CreationDate)
return p.view.DeleteProject(event.AggregateID, event)
default:
return p.view.ProcessedProjectSequence(event.Sequence, event.CreationDate)
return p.view.ProcessedProjectSequence(event)
}
if err != nil {
return err
}
return p.view.PutProject(project, event.CreationDate)
return p.view.PutProject(project, event)
}
func (p *Project) OnError(event *models.Event, err error) error {

67
internal/management/repository/eventsourcing/handler/project_grant.go
View File

@@ -2,12 +2,12 @@ package handler
import (
"context"
"time"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
org_model "github.com/caos/zitadel/internal/org/model"
org_event "github.com/caos/zitadel/internal/org/repository/eventsourcing"
@@ -17,23 +17,60 @@ import (
view_model "github.com/caos/zitadel/internal/project/repository/view/model"
)
type ProjectGrant struct {
handler
eventstore eventstore.Eventstore
projectEvents *proj_event.ProjectEventstore
orgEvents *org_event.OrgEventstore
}
const (
grantedProjectTable = "management.project_grants"
)
type ProjectGrant struct {
handler
projectEvents *proj_event.ProjectEventstore
orgEvents *org_event.OrgEventstore
subscription *eventstore.Subscription
}
func newProjectGrant(
handler handler,
projectEvents *proj_event.ProjectEventstore,
orgEvents *org_event.OrgEventstore,
) *ProjectGrant {
h := &ProjectGrant{
handler: handler,
projectEvents: projectEvents,
orgEvents: orgEvents,
}
h.subscribe()
return h
}
func (m *ProjectGrant) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (p *ProjectGrant) ViewModel() string {
return grantedProjectTable
}
func (_ *ProjectGrant) AggregateTypes() []models.AggregateType {
return []models.AggregateType{es_model.ProjectAggregate}
}
func (p *ProjectGrant) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := p.view.GetLatestProjectGrantSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (p *ProjectGrant) EventQuery() (*models.SearchQuery, error) {
sequence, err := p.view.GetLatestProjectGrantSequence()
sequence, err := p.view.GetLatestProjectGrantSequence("")
if err != nil {
return nil, err
}
@@ -48,7 +85,7 @@ func (p *ProjectGrant) Reduce(event *models.Event) (err error) {
if err != nil {
return err
}
return p.updateExistingProjects(project, event.Sequence, event.CreationDate)
return p.updateExistingProjects(project, event)
case es_model.ProjectGrantAdded:
err = grantedProject.AppendEvent(event)
if err != nil {
@@ -86,16 +123,16 @@ func (p *ProjectGrant) Reduce(event *models.Event) (err error) {
if err != nil {
return err
}
return p.view.DeleteProjectGrant(grant.GrantID, event.Sequence, event.CreationDate)
return p.view.DeleteProjectGrant(grant.GrantID, event)
case es_model.ProjectRemoved:
return p.view.DeleteProjectGrantsByProjectID(event.AggregateID)
default:
return p.view.ProcessedProjectGrantSequence(event.Sequence, event.CreationDate)
return p.view.ProcessedProjectGrantSequence(event)
}
if err != nil {
return err
}
return p.view.PutProjectGrant(grantedProject, event.CreationDate)
return p.view.PutProjectGrant(grantedProject, event)
}
func (p *ProjectGrant) fillOrgData(grantedProject *view_model.ProjectGrantView, org, resourceOwner *org_model.Org) {
@@ -107,7 +144,7 @@ func (p *ProjectGrant) getProject(projectID string) (*proj_model.Project, error)
return p.projectEvents.ProjectByID(context.Background(), projectID)
}
func (p *ProjectGrant) updateExistingProjects(project *view_model.ProjectView, sequence uint64, eventTimestamp time.Time) error {
func (p *ProjectGrant) updateExistingProjects(project *view_model.ProjectView, event *models.Event) error {
projectGrants, err := p.view.ProjectGrantsByProjectID(project.ProjectID)
if err != nil {
logging.LogWithFields("SPOOL-los03", "id", project.ProjectID).WithError(err).Warn("could not update existing projects")
@@ -115,7 +152,7 @@ func (p *ProjectGrant) updateExistingProjects(project *view_model.ProjectView, s
for _, existingGrant := range projectGrants {
existingGrant.Name = project.Name
}
return p.view.PutProjectGrants(projectGrants, sequence, eventTimestamp)
return p.view.PutProjectGrants(projectGrants, event)
}
func (p *ProjectGrant) OnError(event *models.Event, err error) error {

65
internal/management/repository/eventsourcing/handler/project_grant_member.go
View File

@@ -5,8 +5,10 @@ import (
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
proj_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
view_model "github.com/caos/zitadel/internal/project/repository/view/model"
@@ -15,26 +17,62 @@ import (
usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
)
type ProjectGrantMember struct {
handler
userEvents *usr_event.UserEventstore
}
const (
projectGrantMemberTable = "management.project_grant_members"
)
type ProjectGrantMember struct {
handler
userEvents *usr_event.UserEventstore
subscription *eventstore.Subscription
}
func newProjectGrantMember(
handler handler,
userEvents *usr_event.UserEventstore,
) *ProjectGrantMember {
h := &ProjectGrantMember{
handler: handler,
userEvents: userEvents,
}
h.subscribe()
return h
}
func (m *ProjectGrantMember) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (p *ProjectGrantMember) ViewModel() string {
return projectGrantMemberTable
}
func (_ *ProjectGrantMember) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{proj_es_model.ProjectAggregate, usr_es_model.UserAggregate}
}
func (p *ProjectGrantMember) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := p.view.GetLatestProjectGrantMemberSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (p *ProjectGrantMember) EventQuery() (*models.SearchQuery, error) {
sequence, err := p.view.GetLatestProjectGrantMemberSequence()
sequence, err := p.view.GetLatestProjectGrantMemberSequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(proj_es_model.ProjectAggregate, usr_es_model.UserAggregate).
AggregateTypeFilter(p.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -72,16 +110,16 @@ func (p *ProjectGrantMember) processProjectGrantMember(event *models.Event) (err
if err != nil {
return err
}
return p.view.DeleteProjectGrantMember(member.GrantID, member.UserID, event.Sequence, event.CreationDate)
return p.view.DeleteProjectGrantMember(member.GrantID, member.UserID, event)
case proj_es_model.ProjectRemoved:
return p.view.DeleteProjectGrantMembersByProjectID(event.AggregateID)
default:
return p.view.ProcessedProjectGrantMemberSequence(event.Sequence, event.CreationDate)
return p.view.ProcessedProjectGrantMemberSequence(event)
}
if err != nil {
return err
}
return p.view.PutProjectGrantMember(member, member.Sequence, event.CreationDate)
return p.view.PutProjectGrantMember(member, event)
}
func (p *ProjectGrantMember) processUser(event *models.Event) (err error) {
@@ -96,7 +134,7 @@ func (p *ProjectGrantMember) processUser(event *models.Event) (err error) {
return err
}
if len(members) == 0 {
return p.view.ProcessedProjectGrantMemberSequence(event.Sequence, event.CreationDate)
return p.view.ProcessedProjectGrantMemberSequence(event)
}
user, err := p.userEvents.UserByID(context.Background(), event.AggregateID)
if err != nil {
@@ -105,11 +143,10 @@ func (p *ProjectGrantMember) processUser(event *models.Event) (err error) {
for _, member := range members {
p.fillUserData(member, user)
}
return p.view.PutProjectGrantMembers(members, event.Sequence, event.CreationDate)
return p.view.PutProjectGrantMembers(members, event)
default:
return p.view.ProcessedProjectGrantMemberSequence(event.Sequence, event.CreationDate)
return p.view.ProcessedProjectGrantMemberSequence(event)
}
return nil
}
func (p *ProjectGrantMember) fillData(member *view_model.ProjectGrantMemberView) (err error) {

64
internal/management/repository/eventsourcing/handler/project_member.go
View File

@@ -5,8 +5,10 @@ import (
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
proj_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
view_model "github.com/caos/zitadel/internal/project/repository/view/model"
@@ -15,26 +17,62 @@ import (
usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
)
type ProjectMember struct {
handler
userEvents *usr_event.UserEventstore
}
const (
projectMemberTable = "management.project_members"
)
type ProjectMember struct {
handler
userEvents *usr_event.UserEventstore
subscription *eventstore.Subscription
}
func newProjectMember(
handler handler,
userEvents *usr_event.UserEventstore,
) *ProjectMember {
h := &ProjectMember{
handler: handler,
userEvents: userEvents,
}
h.subscribe()
return h
}
func (m *ProjectMember) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (p *ProjectMember) ViewModel() string {
return projectMemberTable
}
func (_ *ProjectMember) AggregateTypes() []models.AggregateType {
return []models.AggregateType{proj_es_model.ProjectAggregate, usr_es_model.UserAggregate}
}
func (p *ProjectMember) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := p.view.GetLatestProjectMemberSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (p *ProjectMember) EventQuery() (*models.SearchQuery, error) {
sequence, err := p.view.GetLatestProjectMemberSequence()
sequence, err := p.view.GetLatestProjectMemberSequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(proj_es_model.ProjectAggregate, usr_es_model.UserAggregate).
AggregateTypeFilter(p.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -72,16 +110,16 @@ func (p *ProjectMember) processProjectMember(event *models.Event) (err error) {
if err != nil {
return err
}
return p.view.DeleteProjectMember(event.AggregateID, member.UserID, event.Sequence, event.CreationDate)
return p.view.DeleteProjectMember(event.AggregateID, member.UserID, event)
case proj_es_model.ProjectRemoved:
return p.view.DeleteProjectMembersByProjectID(event.AggregateID)
default:
return p.view.ProcessedProjectMemberSequence(event.Sequence, event.CreationDate)
return p.view.ProcessedProjectMemberSequence(event)
}
if err != nil {
return err
}
return p.view.PutProjectMember(member, member.Sequence, event.CreationDate)
return p.view.PutProjectMember(member, event)
}
func (p *ProjectMember) processUser(event *models.Event) (err error) {
@@ -96,7 +134,7 @@ func (p *ProjectMember) processUser(event *models.Event) (err error) {
return err
}
if len(members) == 0 {
return p.view.ProcessedProjectMemberSequence(event.Sequence, event.CreationDate)
return p.view.ProcessedProjectMemberSequence(event)
}
user, err := p.userEvents.UserByID(context.Background(), event.AggregateID)
if err != nil {
@@ -105,9 +143,9 @@ func (p *ProjectMember) processUser(event *models.Event) (err error) {
for _, member := range members {
p.fillUserData(member, user)
}
return p.view.PutProjectMembers(members, event.Sequence, event.CreationDate)
return p.view.PutProjectMembers(members, event)
default:
return p.view.ProcessedProjectMemberSequence(event.Sequence, event.CreationDate)
return p.view.ProcessedProjectMemberSequence(event)
}
return nil
}

56
internal/management/repository/eventsourcing/handler/project_role.go
View File

@@ -3,7 +3,9 @@ package handler
import (
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
"github.com/caos/zitadel/internal/project/repository/eventsourcing"
proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
@@ -11,21 +13,57 @@ import (
view_model "github.com/caos/zitadel/internal/project/repository/view/model"
)
type ProjectRole struct {
handler
projectEvents *proj_event.ProjectEventstore
}
const (
projectRoleTable = "management.project_roles"
)
type ProjectRole struct {
handler
projectEvents *proj_event.ProjectEventstore
subscription *eventstore.Subscription
}
func newProjectRole(
handler handler,
projectEvents *proj_event.ProjectEventstore,
) *ProjectRole {
h := &ProjectRole{
handler: handler,
projectEvents: projectEvents,
}
h.subscribe()
return h
}
func (m *ProjectRole) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (p *ProjectRole) ViewModel() string {
return projectRoleTable
}
func (_ *ProjectRole) AggregateTypes() []models.AggregateType {
return []models.AggregateType{es_model.ProjectAggregate}
}
func (p *ProjectRole) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := p.view.GetLatestProjectRoleSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (p *ProjectRole) EventQuery() (*models.SearchQuery, error) {
sequence, err := p.view.GetLatestProjectRoleSequence()
sequence, err := p.view.GetLatestProjectRoleSequence("")
if err != nil {
return nil, err
}
@@ -52,16 +90,16 @@ func (p *ProjectRole) Reduce(event *models.Event) (err error) {
if err != nil {
return err
}
return p.view.DeleteProjectRole(event.AggregateID, event.ResourceOwner, role.Key, event.Sequence, event.CreationDate)
return p.view.DeleteProjectRole(event.AggregateID, event.ResourceOwner, role.Key, event)
case es_model.ProjectRemoved:
return p.view.DeleteProjectRolesByProjectID(event.AggregateID)
default:
return p.view.ProcessedProjectRoleSequence(event.Sequence, event.CreationDate)
return p.view.ProcessedProjectRoleSequence(event)
}
if err != nil {
return err
}
return p.view.PutProjectRole(role, event.CreationDate)
return p.view.PutProjectRole(role, event)
}
func (p *ProjectRole) OnError(event *models.Event, err error) error {

75
internal/management/repository/eventsourcing/handler/user.go
View File

@@ -2,14 +2,14 @@ package handler
import (
"context"
iam_es "github.com/caos/zitadel/internal/iam/repository/eventsourcing"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_es "github.com/caos/zitadel/internal/iam/repository/eventsourcing"
org_model "github.com/caos/zitadel/internal/org/model"
org_events "github.com/caos/zitadel/internal/org/repository/eventsourcing"
org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
@@ -17,29 +17,68 @@ import (
view_model "github.com/caos/zitadel/internal/user/repository/view/model"
)
type User struct {
handler
eventstore eventstore.Eventstore
orgEvents *org_events.OrgEventstore
iamEvents *iam_es.IAMEventstore
iamID string
}
const (
userTable = "management.users"
)
type User struct {
handler
orgEvents *org_events.OrgEventstore
iamEvents *iam_es.IAMEventstore
iamID string
subscription *eventstore.Subscription
}
func newUser(
handler handler,
orgEvents *org_events.OrgEventstore,
iamEvents *iam_es.IAMEventstore,
iamID string,
) *User {
h := &User{
handler: handler,
orgEvents: orgEvents,
iamEvents: iamEvents,
iamID: iamID,
}
h.subscribe()
return h
}
func (m *User) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (u *User) ViewModel() string {
return userTable
}
func (_ *User) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{es_model.UserAggregate, org_es_model.OrgAggregate}
}
func (u *User) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := u.view.GetLatestUserSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (u *User) EventQuery() (*models.SearchQuery, error) {
sequence, err := u.view.GetLatestUserSequence()
sequence, err := u.view.GetLatestUserSequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(es_model.UserAggregate, org_es_model.OrgAggregate).
AggregateTypeFilter(u.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
@@ -115,14 +154,14 @@ func (u *User) ProcessUser(event *models.Event) (err error) {
}
err = u.fillLoginNames(user)
case es_model.UserRemoved:
return u.view.DeleteUser(event.AggregateID, event.Sequence, event.CreationDate)
return u.view.DeleteUser(event.AggregateID, event)
default:
return u.view.ProcessedUserSequence(event.Sequence, event.CreationDate)
return u.view.ProcessedUserSequence(event)
}
if err != nil {
return err
}
return u.view.PutUser(user, user.Sequence, event.CreationDate)
return u.view.PutUser(user, event)
}
func (u *User) ProcessOrg(event *models.Event) (err error) {
@@ -136,7 +175,7 @@ func (u *User) ProcessOrg(event *models.Event) (err error) {
case org_es_model.OrgDomainPrimarySet:
return u.fillPreferredLoginNamesOnOrgUsers(event)
default:
return u.view.ProcessedUserSequence(event.Sequence, event.CreationDate)
return u.view.ProcessedUserSequence(event)
}
}
@@ -159,7 +198,7 @@ func (u *User) fillLoginNamesOnOrgUsers(event *models.Event) error {
for _, user := range users {
user.SetLoginNames(policy, org.Domains)
}
return u.view.PutUsers(users, event.Sequence, event.CreationDate)
return u.view.PutUsers(users, event)
}
func (u *User) fillPreferredLoginNamesOnOrgUsers(event *models.Event) error {
@@ -184,7 +223,7 @@ func (u *User) fillPreferredLoginNamesOnOrgUsers(event *models.Event) error {
for _, user := range users {
user.PreferredLoginName = user.GenerateLoginName(org.GetPrimaryDomain().Domain, policy.UserLoginMustBeDomain)
}
return u.view.PutUsers(users, event.Sequence, event.CreationDate)
return u.view.PutUsers(users, event)
}
func (u *User) fillLoginNames(user *view_model.UserView) (err error) {

84
internal/management/repository/eventsourcing/handler/user_external_idps.go
View File

@@ -2,21 +2,27 @@ package handler
import (
"context"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/config/systemdefaults"
caos_errs "github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_model "github.com/caos/zitadel/internal/iam/model"
"github.com/caos/zitadel/internal/iam/repository/eventsourcing"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
iam_view_model "github.com/caos/zitadel/internal/iam/repository/view/model"
org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
"github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
usr_view_model "github.com/caos/zitadel/internal/user/repository/view/model"
)
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_model "github.com/caos/zitadel/internal/iam/model"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
const (
externalIDPTable = "management.user_external_idps"
)
type ExternalIDP struct {
@@ -24,27 +30,63 @@ type ExternalIDP struct {
systemDefaults systemdefaults.SystemDefaults
iamEvents *eventsourcing.IAMEventstore
orgEvents *org_es.OrgEventstore
subscription *eventstore.Subscription
}
const (
externalIDPTable = "management.user_external_idps"
)
func newExternalIDP(
handler handler,
systemDefaults systemdefaults.SystemDefaults,
iamEvents *eventsourcing.IAMEventstore,
orgEvents *org_es.OrgEventstore,
) *ExternalIDP {
h := &ExternalIDP{
handler: handler,
systemDefaults: systemDefaults,
iamEvents: iamEvents,
orgEvents: orgEvents,
}
h.subscribe()
return h
}
func (m *ExternalIDP) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (i *ExternalIDP) ViewModel() string {
return externalIDPTable
}
func (i *ExternalIDP) EventQuery() (*models.SearchQuery, error) {
sequence, err := i.view.GetLatestExternalIDPSequence()
func (_ *ExternalIDP) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{model.UserAggregate, iam_es_model.IAMAggregate, org_es_model.OrgAggregate}
}
func (i *ExternalIDP) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := i.view.GetLatestExternalIDPSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (i *ExternalIDP) EventQuery() (*es_models.SearchQuery, error) {
sequence, err := i.view.GetLatestExternalIDPSequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(model.UserAggregate, iam_es_model.IAMAggregate, org_es_model.OrgAggregate).
AggregateTypeFilter(i.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
func (i *ExternalIDP) Reduce(event *models.Event) (err error) {
func (i *ExternalIDP) Reduce(event *es_models.Event) (err error) {
switch event.AggregateType {
case model.UserAggregate:
err = i.processUser(event)
@@ -54,7 +96,7 @@ func (i *ExternalIDP) Reduce(event *models.Event) (err error) {
return err
}
func (i *ExternalIDP) processUser(event *models.Event) (err error) {
func (i *ExternalIDP) processUser(event *es_models.Event) (err error) {
externalIDP := new(usr_view_model.ExternalIDPView)
switch event.Type {
case model.HumanExternalIDPAdded:
@@ -68,19 +110,19 @@ func (i *ExternalIDP) processUser(event *models.Event) (err error) {
if err != nil {
return err
}
return i.view.DeleteExternalIDP(externalIDP.ExternalUserID, externalIDP.IDPConfigID, event.Sequence, event.CreationDate)
return i.view.DeleteExternalIDP(externalIDP.ExternalUserID, externalIDP.IDPConfigID, event)
case model.UserRemoved:
return i.view.DeleteExternalIDPsByUserID(event.AggregateID, event.Sequence, event.CreationDate)
return i.view.DeleteExternalIDPsByUserID(event.AggregateID, event)
default:
return i.view.ProcessedExternalIDPSequence(event.Sequence, event.CreationDate)
return i.view.ProcessedExternalIDPSequence(event)
}
if err != nil {
return err
}
return i.view.PutExternalIDP(externalIDP, externalIDP.Sequence, event.CreationDate)
return i.view.PutExternalIDP(externalIDP, event)
}
func (i *ExternalIDP) processIdpConfig(event *models.Event) (err error) {
func (i *ExternalIDP) processIdpConfig(event *es_models.Event) (err error) {
switch event.Type {
case iam_es_model.IDPConfigChanged, org_es_model.IDPConfigChanged:
configView := new(iam_view_model.IDPConfigView)
@@ -105,9 +147,9 @@ func (i *ExternalIDP) processIdpConfig(event *models.Event) (err error) {
for _, provider := range exterinalIDPs {
i.fillConfigData(provider, config)
}
return i.view.PutExternalIDPs(event.Sequence, event.CreationDate, exterinalIDPs...)
return i.view.PutExternalIDPs(event, exterinalIDPs...)
default:
return i.view.ProcessedExternalIDPSequence(event.Sequence, event.CreationDate)
return i.view.ProcessedExternalIDPSequence(event)
}
return nil
}
@@ -128,7 +170,7 @@ func (i *ExternalIDP) fillConfigData(externalIDP *usr_view_model.ExternalIDPView
externalIDP.IDPName = config.Name
}
func (i *ExternalIDP) OnError(event *models.Event, err error) error {
func (i *ExternalIDP) OnError(event *es_models.Event, err error) error {
logging.LogWithFields("SPOOL-4Rsu8", "id", event.AggregateID).WithError(err).Warn("something went wrong in idp provider handler")
return spooler.HandleError(event, err, i.view.GetLatestExternalIDPFailedEvent, i.view.ProcessedExternalIDPFailedEvent, i.view.ProcessedExternalIDPSequence, i.errorCountUntilSkip)
}

100
internal/management/repository/eventsourcing/handler/user_grant.go
View File

@@ -3,7 +3,12 @@ package handler
import (
"context"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
org_model "github.com/caos/zitadel/internal/org/model"
org_events "github.com/caos/zitadel/internal/org/repository/eventsourcing"
proj_model "github.com/caos/zitadel/internal/project/model"
@@ -13,42 +18,75 @@ import (
usr_events "github.com/caos/zitadel/internal/user/repository/eventsourcing"
usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
grant_es_model "github.com/caos/zitadel/internal/usergrant/repository/eventsourcing/model"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/spooler"
view_model "github.com/caos/zitadel/internal/usergrant/repository/view/model"
)
type UserGrant struct {
handler
eventstore eventstore.Eventstore
projectEvents *proj_event.ProjectEventstore
userEvents *usr_events.UserEventstore
orgEvents *org_events.OrgEventstore
}
const (
userGrantTable = "management.user_grants"
)
type UserGrant struct {
handler
projectEvents *proj_event.ProjectEventstore
userEvents *usr_events.UserEventstore
orgEvents *org_events.OrgEventstore
subscription *eventstore.Subscription
}
func newUserGrant(
handler handler,
projectEvents *proj_event.ProjectEventstore,
userEvents *usr_events.UserEventstore,
orgEvents *org_events.OrgEventstore,
) *UserGrant {
h := &UserGrant{
handler: handler,
projectEvents: projectEvents,
userEvents: userEvents,
orgEvents: orgEvents,
}
h.subscribe()
return h
}
func (m *UserGrant) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (u *UserGrant) ViewModel() string {
return userGrantTable
}
func (u *UserGrant) EventQuery() (*models.SearchQuery, error) {
sequence, err := u.view.GetLatestUserGrantSequence()
func (_ *UserGrant) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{grant_es_model.UserGrantAggregate, usr_es_model.UserAggregate, proj_es_model.ProjectAggregate}
}
func (u *UserGrant) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := u.view.GetLatestUserGrantSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (u *UserGrant) EventQuery() (*es_models.SearchQuery, error) {
sequence, err := u.view.GetLatestUserGrantSequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(grant_es_model.UserGrantAggregate, usr_es_model.UserAggregate, proj_es_model.ProjectAggregate).
AggregateTypeFilter(u.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
func (u *UserGrant) Reduce(event *models.Event) (err error) {
func (u *UserGrant) Reduce(event *es_models.Event) (err error) {
switch event.AggregateType {
case grant_es_model.UserGrantAggregate:
err = u.processUserGrant(event)
@@ -60,7 +98,7 @@ func (u *UserGrant) Reduce(event *models.Event) (err error) {
return err
}
func (u *UserGrant) processUserGrant(event *models.Event) (err error) {
func (u *UserGrant) processUserGrant(event *es_models.Event) (err error) {
grant := new(view_model.UserGrantView)
switch event.Type {
case grant_es_model.UserGrantAdded:
@@ -79,17 +117,17 @@ func (u *UserGrant) processUserGrant(event *models.Event) (err error) {
}
err = grant.AppendEvent(event)
case grant_es_model.UserGrantRemoved, grant_es_model.UserGrantCascadeRemoved:
return u.view.DeleteUserGrant(event.AggregateID, event.Sequence, event.CreationDate)
return u.view.DeleteUserGrant(event.AggregateID, event)
default:
return u.view.ProcessedUserGrantSequence(event.Sequence, event.CreationDate)
return u.view.ProcessedUserGrantSequence(event)
}
if err != nil {
return err
}
return u.view.PutUserGrant(grant, grant.Sequence, event.CreationDate)
return u.view.PutUserGrant(grant, event)
}
func (u *UserGrant) processUser(event *models.Event) (err error) {
func (u *UserGrant) processUser(event *es_models.Event) (err error) {
switch event.Type {
case usr_es_model.UserProfileChanged,
usr_es_model.UserEmailChanged,
@@ -101,7 +139,7 @@ func (u *UserGrant) processUser(event *models.Event) (err error) {
return err
}
if len(grants) == 0 {
return u.view.ProcessedUserGrantSequence(event.Sequence, event.CreationDate)
return u.view.ProcessedUserGrantSequence(event)
}
user, err := u.userEvents.UserByID(context.Background(), event.AggregateID)
if err != nil {
@@ -110,14 +148,14 @@ func (u *UserGrant) processUser(event *models.Event) (err error) {
for _, grant := range grants {
u.fillUserData(grant, user)
}
return u.view.PutUserGrants(grants, event.Sequence, event.CreationDate)
return u.view.PutUserGrants(grants, event)
default:
return u.view.ProcessedUserGrantSequence(event.Sequence, event.CreationDate)
return u.view.ProcessedUserGrantSequence(event)
}
return nil
}
func (u *UserGrant) processProject(event *models.Event) (err error) {
func (u *UserGrant) processProject(event *es_models.Event) (err error) {
switch event.Type {
case proj_es_model.ProjectChanged:
grants, err := u.view.UserGrantsByProjectID(event.AggregateID)
@@ -125,7 +163,7 @@ func (u *UserGrant) processProject(event *models.Event) (err error) {
return err
}
if len(grants) == 0 {
return u.view.ProcessedUserGrantSequence(event.Sequence, event.CreationDate)
return u.view.ProcessedUserGrantSequence(event)
}
project, err := u.projectEvents.ProjectByID(context.Background(), event.AggregateID)
if err != nil {
@@ -134,9 +172,9 @@ func (u *UserGrant) processProject(event *models.Event) (err error) {
for _, grant := range grants {
u.fillProjectData(grant, project)
}
return u.view.PutUserGrants(grants, event.Sequence, event.CreationDate)
return u.view.PutUserGrants(grants, event)
default:
return u.view.ProcessedUserGrantSequence(event.Sequence, event.CreationDate)
return u.view.ProcessedUserGrantSequence(event)
}
return nil
}
@@ -189,7 +227,7 @@ func (u *UserGrant) fillOrgData(grant *view_model.UserGrantView, org *org_model.
}
}
func (u *UserGrant) OnError(event *models.Event, err error) error {
func (u *UserGrant) OnError(event *es_models.Event, err error) error {
logging.LogWithFields("SPOOL-8is4s", "id", event.AggregateID).WithError(err).Warn("something went wrong in user handler")
return spooler.HandleError(event, err, u.view.GetLatestUserGrantFailedEvent, u.view.ProcessedUserGrantFailedEvent, u.view.ProcessedUserGrantSequence, u.errorCountUntilSkip)
}

115
internal/management/repository/eventsourcing/handler/user_membership.go
View File

@@ -2,48 +2,87 @@ package handler
import (
"context"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/query"
"github.com/caos/zitadel/internal/eventstore/spooler"
iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
org_model "github.com/caos/zitadel/internal/org/model"
org_event "github.com/caos/zitadel/internal/org/repository/eventsourcing"
org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
proj_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
"github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/eventstore/models"
es_models "github.com/caos/zitadel/internal/eventstore/models"
"github.com/caos/zitadel/internal/eventstore/spooler"
org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
usr_model "github.com/caos/zitadel/internal/user/model"
"github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
usr_es_model "github.com/caos/zitadel/internal/user/repository/view/model"
)
const (
userMembershipTable = "management.user_memberships"
)
type UserMembership struct {
handler
orgEvents *org_event.OrgEventstore
projectEvents *proj_event.ProjectEventstore
subscription *eventstore.Subscription
}
const (
userMembershipTable = "management.user_memberships"
)
func newUserMembership(
handler handler,
orgEvents *org_event.OrgEventstore,
projectEvents *proj_event.ProjectEventstore,
) *UserMembership {
h := &UserMembership{
handler: handler,
orgEvents: orgEvents,
projectEvents: projectEvents,
}
h.subscribe()
return h
}
func (m *UserMembership) subscribe() {
m.subscription = m.es.Subscribe(m.AggregateTypes()...)
go func() {
for event := range m.subscription.Events {
query.ReduceEvent(m, event)
}
}()
}
func (m *UserMembership) ViewModel() string {
return userMembershipTable
}
func (m *UserMembership) EventQuery() (*models.SearchQuery, error) {
sequence, err := m.view.GetLatestUserMembershipSequence()
func (_ *UserMembership) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{iam_es_model.IAMAggregate, org_es_model.OrgAggregate, proj_es_model.ProjectAggregate, model.UserAggregate}
}
func (u *UserMembership) CurrentSequence(event *models.Event) (uint64, error) {
sequence, err := u.view.GetLatestUserMembershipSequence(string(event.AggregateType))
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (m *UserMembership) EventQuery() (*es_models.SearchQuery, error) {
sequence, err := m.view.GetLatestUserMembershipSequence("")
if err != nil {
return nil, err
}
return es_models.NewSearchQuery().
AggregateTypeFilter(iam_es_model.IAMAggregate, org_es_model.OrgAggregate, proj_es_model.ProjectAggregate, model.UserAggregate).
AggregateTypeFilter(m.AggregateTypes()...).
LatestSequenceFilter(sequence.CurrentSequence), nil
}
func (m *UserMembership) Reduce(event *models.Event) (err error) {
func (m *UserMembership) Reduce(event *es_models.Event) (err error) {
switch event.AggregateType {
case iam_es_model.IAMAggregate:
err = m.processIam(event)
@@ -57,7 +96,7 @@ func (m *UserMembership) Reduce(event *models.Event) (err error) {
return err
}
func (m *UserMembership) processIam(event *models.Event) (err error) {
func (m *UserMembership) processIam(event *es_models.Event) (err error) {
member := new(usr_es_model.UserMembershipView)
err = member.AppendEvent(event)
if err != nil {
@@ -73,21 +112,21 @@ func (m *UserMembership) processIam(event *models.Event) (err error) {
}
err = member.AppendEvent(event)
case iam_es_model.IAMMemberRemoved:
return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeIam, event.Sequence, event.CreationDate)
return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeIam, event)
default:
return m.view.ProcessedUserMembershipSequence(event.Sequence, event.CreationDate)
return m.view.ProcessedUserMembershipSequence(event)
}
if err != nil {
return err
}
return m.view.PutUserMembership(member, event.Sequence, event.CreationDate)
return m.view.PutUserMembership(member, event)
}
func (m *UserMembership) fillIamDisplayName(member *usr_es_model.UserMembershipView) {
member.DisplayName = member.AggregateID
}
func (m *UserMembership) processOrg(event *models.Event) (err error) {
func (m *UserMembership) processOrg(event *es_models.Event) (err error) {
member := new(usr_es_model.UserMembershipView)
err = member.AppendEvent(event)
if err != nil {
@@ -103,16 +142,16 @@ func (m *UserMembership) processOrg(event *models.Event) (err error) {
}
err = member.AppendEvent(event)
case org_es_model.OrgMemberRemoved:
return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeOrganisation, event.Sequence, event.CreationDate)
return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeOrganisation, event)
case org_es_model.OrgChanged:
return m.updateOrgDisplayName(event)
default:
return m.view.ProcessedUserMembershipSequence(event.Sequence, event.CreationDate)
return m.view.ProcessedUserMembershipSequence(event)
}
if err != nil {
return err
}
return m.view.PutUserMembership(member, event.Sequence, event.CreationDate)
return m.view.PutUserMembership(member, event)
}
func (m *UserMembership) fillOrgDisplayName(member *usr_es_model.UserMembershipView) (err error) {
@@ -124,7 +163,7 @@ func (m *UserMembership) fillOrgDisplayName(member *usr_es_model.UserMembershipV
return nil
}
func (m *UserMembership) updateOrgDisplayName(event *models.Event) error {
func (m *UserMembership) updateOrgDisplayName(event *es_models.Event) error {
org, err := m.orgEvents.OrgByID(context.Background(), org_model.NewOrg(event.AggregateID))
if err != nil {
return err
@@ -137,10 +176,10 @@ func (m *UserMembership) updateOrgDisplayName(event *models.Event) error {
for _, membership := range memberships {
membership.DisplayName = org.Name
}
return m.view.BulkPutUserMemberships(memberships, event.Sequence, event.CreationDate)
return m.view.BulkPutUserMemberships(memberships, event)
}
func (m *UserMembership) processProject(event *models.Event) (err error) {
func (m *UserMembership) processProject(event *es_models.Event) (err error) {
member := new(usr_es_model.UserMembershipView)
err = member.AppendEvent(event)
if err != nil {
@@ -156,7 +195,7 @@ func (m *UserMembership) processProject(event *models.Event) (err error) {
}
err = member.AppendEvent(event)
case proj_es_model.ProjectMemberRemoved:
return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeProject, event.Sequence, event.CreationDate)
return m.view.DeleteUserMembership(member.UserID, event.AggregateID, event.AggregateID, usr_model.MemberTypeProject, event)
case proj_es_model.ProjectGrantMemberChanged:
member, err = m.view.UserMembershipByIDs(member.UserID, event.AggregateID, member.ObjectID, usr_model.MemberTypeProjectGrant)
if err != nil {
@@ -164,20 +203,20 @@ func (m *UserMembership) processProject(event *models.Event) (err error) {
}
err = member.AppendEvent(event)
case proj_es_model.ProjectGrantMemberRemoved:
return m.view.DeleteUserMembership(member.UserID, event.AggregateID, member.ObjectID, usr_model.MemberTypeProjectGrant, event.Sequence, event.CreationDate)
return m.view.DeleteUserMembership(member.UserID, event.AggregateID, member.ObjectID, usr_model.MemberTypeProjectGrant, event)
case proj_es_model.ProjectChanged:
return m.updateProjectDisplayName(event)
case proj_es_model.ProjectRemoved:
return m.view.DeleteUserMembershipsByAggregateID(event.AggregateID, event.Sequence, event.CreationDate)
return m.view.DeleteUserMembershipsByAggregateID(event.AggregateID, event)
case proj_es_model.ProjectGrantRemoved:
return m.view.DeleteUserMembershipsByAggregateIDAndObjectID(event.AggregateID, member.ObjectID, event.Sequence, event.CreationDate)
return m.view.DeleteUserMembershipsByAggregateIDAndObjectID(event.AggregateID, member.ObjectID, event)
default:
return m.view.ProcessedUserMembershipSequence(event.Sequence, event.CreationDate)
return m.view.ProcessedUserMembershipSequence(event)
}
if err != nil {
return err
}
return m.view.PutUserMembership(member, event.Sequence, event.CreationDate)
return m.view.PutUserMembership(member, event)
}
func (m *UserMembership) fillProjectDisplayName(member *usr_es_model.UserMembershipView) (err error) {
@@ -189,7 +228,7 @@ func (m *UserMembership) fillProjectDisplayName(member *usr_es_model.UserMembers
return nil
}
func (m *UserMembership) updateProjectDisplayName(event *models.Event) error {
func (m *UserMembership) updateProjectDisplayName(event *es_models.Event) error {
project, err := m.projectEvents.ProjectByID(context.Background(), event.AggregateID)
if err != nil {
return err
@@ -202,19 +241,19 @@ func (m *UserMembership) updateProjectDisplayName(event *models.Event) error {
for _, membership := range memberships {
membership.DisplayName = project.Name
}
return m.view.BulkPutUserMemberships(memberships, event.Sequence, event.CreationDate)
return m.view.BulkPutUserMemberships(memberships, event)
}
func (m *UserMembership) processUser(event *models.Event) (err error) {
func (m *UserMembership) processUser(event *es_models.Event) (err error) {
switch event.Type {
case model.UserRemoved:
return m.view.DeleteUserMembershipsByUserID(event.AggregateID, event.Sequence, event.CreationDate)
return m.view.DeleteUserMembershipsByUserID(event.AggregateID, event)
default:
return m.view.ProcessedUserMembershipSequence(event.Sequence, event.CreationDate)
return m.view.ProcessedUserMembershipSequence(event)
}
}
func (m *UserMembership) OnError(event *models.Event, err error) error {
func (m *UserMembership) OnError(event *es_models.Event, err error) error {
logging.LogWithFields("SPOOL-Fwer2", "id", event.AggregateID).WithError(err).Warn("something went wrong in user membership handler")
return spooler.HandleError(event, err, m.view.GetLatestUserMembershipFailedEvent, m.view.ProcessedUserMembershipFailedEvent, m.view.ProcessedUserMembershipSequence, m.errorCountUntilSkip)
}