TheArchive/zitadel
1
0
Fork 0
mirror of https://github.com/zitadel/zitadel.git synced 2025-08-12 03:57:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: move activity log to queries and remove old code (#3096)

Browse Source 
* move changes to queries and remove old code

* fix changes query

* remove unused code

* fix sorting

* fix sorting

* refactor and remove old code

* remove accidental go.mod replace

* add missing file

* remove listDetail from ChangesResponse
This commit is contained in:
Livio Amstutz
2022-01-26 10:16:33 +01:00
committed by GitHub
parent 52da2354a3
commit e99b7f4972
100 changed files with 579 additions and 3565 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
internal/query/changes.go Normal file
View File

@@ -0,0 +1,122 @@
package query
import (
"context"
"time"
"github.com/caos/logging"
"github.com/caos/zitadel/internal/repository/user"
"github.com/caos/zitadel/internal/repository/project"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/errors"
)
type Changes struct {
Changes []*Change
}
type Change struct {
ChangeDate time.Time
EventType string
Sequence uint64
ResourceOwner string
ModifierId string
ModifierName string
ModifierLoginName string
ModifierResourceOwner string
ModifierAvatarKey string
}
func (q *Queries) OrgChanges(ctx context.Context, orgID string, lastSequence uint64, limit uint64, sortAscending bool, auditLogRetention time.Duration) (*Changes, error) {
query := func(query *eventstore.SearchQuery) {
query.AggregateTypes(org.AggregateType).
AggregateIDs(orgID)
}
return q.changes(ctx, query, lastSequence, limit, sortAscending, auditLogRetention)
}
func (q *Queries) ProjectChanges(ctx context.Context, projectID string, lastSequence uint64, limit uint64, sortAscending bool, auditLogRetention time.Duration) (*Changes, error) {
query := func(query *eventstore.SearchQuery) {
query.AggregateTypes(project.AggregateType).
AggregateIDs(projectID)
}
return q.changes(ctx, query, lastSequence, limit, sortAscending, auditLogRetention)
}
func (q *Queries) ApplicationChanges(ctx context.Context, projectID, appID string, lastSequence uint64, limit uint64, sortAscending bool, auditLogRetention time.Duration) (*Changes, error) {
query := func(query *eventstore.SearchQuery) {
query.AggregateTypes(project.AggregateType).
AggregateIDs(projectID).
EventData(map[string]interface{}{
"appId": appID,
})
}
return q.changes(ctx, query, lastSequence, limit, sortAscending, auditLogRetention)
}
func (q *Queries) UserChanges(ctx context.Context, userID string, lastSequence uint64, limit uint64, sortAscending bool, auditLogRetention time.Duration) (*Changes, error) {
query := func(query *eventstore.SearchQuery) {
query.AggregateTypes(user.AggregateType).
AggregateIDs(userID)
}
return q.changes(ctx, query, lastSequence, limit, sortAscending, auditLogRetention)
}
func (q *Queries) changes(ctx context.Context, query func(query *eventstore.SearchQuery), lastSequence uint64, limit uint64, sortAscending bool, auditLogRetention time.Duration) (*Changes, error) {
builder := eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).Limit(limit)
if !sortAscending {
builder.OrderDesc()
}
search := builder.AddQuery().SequenceGreater(lastSequence) //always use greater (less is done automatically by sorting desc)
query(search)
events, err := q.eventstore.Filter(ctx, builder)
if err != nil {
logging.Log("QUERY-ZRffs").WithError(err).Warn("eventstore unavailable")
return nil, errors.ThrowInternal(err, "QUERY-328b1", "Errors.Internal")
}
if len(events) == 0 {
return nil, errors.ThrowNotFound(nil, "QUERY-FpQqK", "Errors.Changes.NotFound")
}
changes := make([]*Change, 0, len(events))
for _, event := range events {
if event.CreationDate().Before(time.Now().Add(-auditLogRetention)) {
continue
}
change := &Change{
ChangeDate: event.CreationDate(),
EventType: string(event.Type()),
Sequence: event.Sequence(),
ResourceOwner: event.Aggregate().ResourceOwner,
ModifierId: event.EditorUser(),
ModifierName: event.EditorUser(),
ModifierLoginName: event.EditorUser(),
}
editor, _ := q.GetUserByID(ctx, change.ModifierId)
if editor != nil {
change.ModifierLoginName = editor.PreferredLoginName
change.ModifierResourceOwner = editor.ResourceOwner
if editor.Human != nil {
change.ModifierName = editor.Human.DisplayName
change.ModifierAvatarKey = editor.Human.AvatarKey
}
if editor.Machine != nil {
change.ModifierName = editor.Machine.Name
}
}
changes = append(changes, change)
}
if len(changes) == 0 {
return nil, errors.ThrowPreconditionFailed(nil, "QUERY-DEGS2", "Errors.Changes.AuditRetention")
}
return &Changes{
Changes: changes,
}, nil
}

27
internal/query/converter.go
View File

@@ -1,27 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/eventstore/v1/models"
"github.com/caos/zitadel/internal/iam/model"
)
func readModelToIAM(readModel *ReadModel) *model.IAM {
return &model.IAM{
ObjectRoot: readModelToObjectRoot(readModel.ReadModel),
GlobalOrgID: readModel.GlobalOrgID,
IAMProjectID: readModel.ProjectID,
SetUpDone: readModel.SetUpDone,
SetUpStarted: readModel.SetUpStarted,
}
}
func readModelToObjectRoot(readModel eventstore.ReadModel) models.ObjectRoot {
return models.ObjectRoot{
AggregateID: readModel.AggregateID,
ChangeDate: readModel.ChangeDate,
CreationDate: readModel.CreationDate,
ResourceOwner: readModel.ResourceOwner,
Sequence: readModel.ProcessedSequence,
}
}

55
internal/query/iam_idp_config_model.go
View File

@@ -1,55 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
)
type IAMIDPConfigReadModel struct {
IDPConfigReadModel
iamID string
configID string
}
func NewIAMIDPConfigReadModel(iamID, configID string) *IAMIDPConfigReadModel {
return &IAMIDPConfigReadModel{
iamID: iamID,
configID: configID,
}
}
func (rm *IAMIDPConfigReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.IDPConfigAddedEvent:
rm.IDPConfigReadModel.AppendEvents(&e.IDPConfigAddedEvent)
case *iam.IDPConfigChangedEvent:
rm.IDPConfigReadModel.AppendEvents(&e.IDPConfigChangedEvent)
case *iam.IDPConfigDeactivatedEvent:
rm.IDPConfigReadModel.AppendEvents(&e.IDPConfigDeactivatedEvent)
case *iam.IDPConfigReactivatedEvent:
rm.IDPConfigReadModel.AppendEvents(&e.IDPConfigReactivatedEvent)
case *iam.IDPConfigRemovedEvent:
rm.IDPConfigReadModel.AppendEvents(&e.IDPConfigRemovedEvent)
case *iam.IDPOIDCConfigAddedEvent:
rm.IDPConfigReadModel.AppendEvents(&e.OIDCConfigAddedEvent)
case *iam.IDPOIDCConfigChangedEvent:
rm.IDPConfigReadModel.AppendEvents(&e.OIDCConfigChangedEvent)
case *iam.IDPJWTConfigAddedEvent:
rm.IDPConfigReadModel.AppendEvents(&e.JWTConfigAddedEvent)
case *iam.IDPJWTConfigChangedEvent:
rm.IDPConfigReadModel.AppendEvents(&e.JWTConfigChangedEvent)
}
}
}
func (rm *IAMIDPConfigReadModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateIDs(rm.iamID).
EventData(map[string]interface{}{
"idpConfigId": rm.configID,
}).Builder()
}

31
internal/query/iam_idp_configs_model.go
View File

@@ -1,31 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
)
type IAMIDPConfigsReadModel struct {
IDPConfigsReadModel
}
func (rm *IAMIDPConfigsReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.IDPConfigAddedEvent:
rm.IDPConfigsReadModel.AppendEvents(&e.IDPConfigAddedEvent)
case *iam.IDPConfigChangedEvent:
rm.IDPConfigsReadModel.AppendEvents(&e.IDPConfigChangedEvent)
case *iam.IDPConfigDeactivatedEvent:
rm.IDPConfigsReadModel.AppendEvents(&e.IDPConfigDeactivatedEvent)
case *iam.IDPConfigReactivatedEvent:
rm.IDPConfigsReadModel.AppendEvents(&e.IDPConfigReactivatedEvent)
case *iam.IDPConfigRemovedEvent:
rm.IDPConfigsReadModel.AppendEvents(&e.IDPConfigRemovedEvent)
case *iam.IDPOIDCConfigAddedEvent:
rm.IDPConfigsReadModel.AppendEvents(&e.OIDCConfigAddedEvent)
case *iam.IDPOIDCConfigChangedEvent:
rm.IDPConfigsReadModel.AppendEvents(&e.OIDCConfigChangedEvent)
}
}
}

45
internal/query/iam_member_model.go
View File

@@ -1,45 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/member"
)
type IAMMemberReadModel struct {
MemberReadModel
userID string
iamID string
}
func NewIAMMemberReadModel(iamID, userID string) *IAMMemberReadModel {
return &IAMMemberReadModel{
iamID: iamID,
userID: userID,
}
}
func (rm *IAMMemberReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.MemberAddedEvent:
rm.MemberReadModel.AppendEvents(&e.MemberAddedEvent)
case *iam.MemberChangedEvent:
rm.MemberReadModel.AppendEvents(&e.MemberChangedEvent)
case *member.MemberAddedEvent, *member.MemberChangedEvent,
*iam.MemberRemovedEvent, *iam.MemberCascadeRemovedEvent:
rm.MemberReadModel.AppendEvents(e)
}
}
}
func (rm *IAMMemberReadModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateIDs(rm.iamID).
EventData(map[string]interface{}{
"userId": rm.userID,
}).Builder()
}

25
internal/query/iam_members_model.go
View File

@@ -1,25 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
)
type IAMMembersReadModel struct {
MembersReadModel
}
func (rm *IAMMembersReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.MemberAddedEvent:
rm.MembersReadModel.AppendEvents(&e.MemberAddedEvent)
case *iam.MemberChangedEvent:
rm.MembersReadModel.AppendEvents(&e.MemberChangedEvent)
case *iam.MemberRemovedEvent:
rm.MembersReadModel.AppendEvents(&e.MemberRemovedEvent)
case *iam.MemberCascadeRemovedEvent:
rm.MembersReadModel.AppendEvents(&e.MemberCascadeRemovedEvent)
}
}
}

136
internal/query/iam_model.go
View File

@@ -1,136 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/member"
"github.com/caos/zitadel/internal/repository/policy"
)
type ReadModel struct {
eventstore.ReadModel
SetUpStarted domain.Step
SetUpDone domain.Step
Members IAMMembersReadModel
IDPs IAMIDPConfigsReadModel
GlobalOrgID string
ProjectID string
DefaultLoginPolicy IAMLoginPolicyReadModel
DefaultLabelPolicy IAMLabelPolicyReadModel
DefaultOrgIAMPolicy IAMOrgIAMPolicyReadModel
DefaultPasswordComplexityPolicy IAMPasswordComplexityPolicyReadModel
DefaultPasswordAgePolicy IAMPasswordAgePolicyReadModel
DefaultPasswordLockoutPolicy IAMLockoutPolicyReadModel
}
func NewReadModel(id string) *ReadModel {
return &ReadModel{
ReadModel: eventstore.ReadModel{
AggregateID: id,
},
}
}
func (rm *ReadModel) IDPByID(idpID string) *IAMIDPConfigReadModel {
_, config := rm.IDPs.ConfigByID(idpID)
if config == nil {
return nil
}
return &IAMIDPConfigReadModel{IDPConfigReadModel: *config}
}
func (rm *ReadModel) AppendEvents(events ...eventstore.Event) {
rm.ReadModel.AppendEvents(events...)
for _, event := range events {
switch event.(type) {
case *member.MemberAddedEvent,
*member.MemberChangedEvent,
*member.MemberRemovedEvent:
rm.Members.AppendEvents(event)
case *iam.IDPConfigAddedEvent,
*iam.IDPConfigChangedEvent,
*iam.IDPConfigDeactivatedEvent,
*iam.IDPConfigReactivatedEvent,
*iam.IDPConfigRemovedEvent,
*iam.IDPOIDCConfigAddedEvent,
*iam.IDPOIDCConfigChangedEvent:
rm.IDPs.AppendEvents(event)
case *policy.LabelPolicyAddedEvent,
*policy.LabelPolicyChangedEvent:
rm.DefaultLabelPolicy.AppendEvents(event)
case *policy.LoginPolicyAddedEvent,
*policy.LoginPolicyChangedEvent:
rm.DefaultLoginPolicy.AppendEvents(event)
case *policy.OrgIAMPolicyAddedEvent:
rm.DefaultOrgIAMPolicy.AppendEvents(event)
case *policy.PasswordComplexityPolicyAddedEvent,
*policy.PasswordComplexityPolicyChangedEvent:
rm.DefaultPasswordComplexityPolicy.AppendEvents(event)
case *policy.PasswordAgePolicyAddedEvent,
*policy.PasswordAgePolicyChangedEvent:
rm.DefaultPasswordAgePolicy.AppendEvents(event)
case *policy.LockoutPolicyAddedEvent,
*policy.LockoutPolicyChangedEvent:
rm.DefaultPasswordLockoutPolicy.AppendEvents(event)
}
}
}
func (rm *ReadModel) Reduce() (err error) {
for _, event := range rm.Events {
switch e := event.(type) {
case *iam.ProjectSetEvent:
rm.ProjectID = e.ProjectID
case *iam.GlobalOrgSetEvent:
rm.GlobalOrgID = e.OrgID
case *iam.SetupStepEvent:
if e.Done {
rm.SetUpDone = e.Step
} else {
rm.SetUpStarted = e.Step
}
}
}
for _, reduce := range []func() error{
rm.Members.Reduce,
rm.IDPs.Reduce,
rm.DefaultLoginPolicy.Reduce,
rm.DefaultLabelPolicy.Reduce,
rm.DefaultOrgIAMPolicy.Reduce,
rm.DefaultPasswordComplexityPolicy.Reduce,
rm.DefaultPasswordAgePolicy.Reduce,
rm.DefaultPasswordLockoutPolicy.Reduce,
rm.ReadModel.Reduce,
} {
if err = reduce(); err != nil {
return err
}
}
return nil
}
func (rm *ReadModel) AppendAndReduce(events ...eventstore.Event) error {
rm.AppendEvents(events...)
return rm.Reduce()
}
func (rm *ReadModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
AddQuery().
AggregateTypes(iam.AggregateType).
AggregateIDs(rm.AggregateID).
Builder()
}

22
internal/query/iam_policy_label_model.go
View File

@@ -1,22 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMLabelPolicyReadModel struct{ LabelPolicyReadModel }
func (rm *IAMLabelPolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.LabelPolicyAddedEvent:
rm.LabelPolicyReadModel.AppendEvents(&e.LabelPolicyAddedEvent)
case *iam.LabelPolicyChangedEvent:
rm.LabelPolicyReadModel.AppendEvents(&e.LabelPolicyChangedEvent)
case *policy.LabelPolicyAddedEvent, *policy.LabelPolicyChangedEvent:
rm.LabelPolicyReadModel.AppendEvents(e)
}
}
}

22
internal/query/iam_policy_login_model.go
View File

@@ -1,22 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMLoginPolicyReadModel struct{ LoginPolicyReadModel }
func (rm *IAMLoginPolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.LoginPolicyAddedEvent:
rm.LoginPolicyReadModel.AppendEvents(&e.LoginPolicyAddedEvent)
case *iam.LoginPolicyChangedEvent:
rm.LoginPolicyReadModel.AppendEvents(&e.LoginPolicyChangedEvent)
case *policy.LoginPolicyAddedEvent, *policy.LoginPolicyChangedEvent:
rm.LoginPolicyReadModel.AppendEvents(e)
}
}
}

20
internal/query/iam_policy_org_iam_model.go
View File

@@ -1,20 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMOrgIAMPolicyReadModel struct{ OrgIAMPolicyReadModel }
func (rm *IAMOrgIAMPolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.OrgIAMPolicyAddedEvent:
rm.OrgIAMPolicyReadModel.AppendEvents(&e.OrgIAMPolicyAddedEvent)
case *policy.OrgIAMPolicyAddedEvent:
rm.OrgIAMPolicyReadModel.AppendEvents(e)
}
}
}

26
internal/query/iam_policy_password_age_model.go
View File

@@ -1,26 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMPasswordAgePolicyReadModel struct {
PasswordAgePolicyReadModel
}
func (rm *IAMPasswordAgePolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.PasswordAgePolicyAddedEvent:
rm.PasswordAgePolicyReadModel.AppendEvents(&e.PasswordAgePolicyAddedEvent)
case *iam.PasswordAgePolicyChangedEvent:
rm.PasswordAgePolicyReadModel.AppendEvents(&e.PasswordAgePolicyChangedEvent)
case *policy.PasswordAgePolicyAddedEvent,
*policy.PasswordAgePolicyChangedEvent:
rm.PasswordAgePolicyReadModel.AppendEvents(e)
}
}
}

26
internal/query/iam_policy_password_complexity_model.go
View File

@@ -1,26 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMPasswordComplexityPolicyReadModel struct {
PasswordComplexityPolicyReadModel
}
func (rm *IAMPasswordComplexityPolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.PasswordComplexityPolicyAddedEvent:
rm.PasswordComplexityPolicyReadModel.AppendEvents(&e.PasswordComplexityPolicyAddedEvent)
case *iam.PasswordComplexityPolicyChangedEvent:
rm.PasswordComplexityPolicyReadModel.AppendEvents(&e.PasswordComplexityPolicyChangedEvent)
case *policy.PasswordComplexityPolicyAddedEvent,
*policy.PasswordComplexityPolicyChangedEvent:
rm.PasswordComplexityPolicyReadModel.AppendEvents(e)
}
}
}

24
internal/query/iam_policy_password_lockout_model.go
View File

@@ -1,24 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/iam"
"github.com/caos/zitadel/internal/repository/policy"
)
type IAMLockoutPolicyReadModel struct {
LockoutPolicyReadModel
}
func (rm *IAMLockoutPolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *iam.LockoutPolicyAddedEvent:
rm.LockoutPolicyReadModel.AppendEvents(&e.LockoutPolicyAddedEvent)
case *iam.LockoutPolicyChangedEvent:
rm.LockoutPolicyReadModel.AppendEvents(&e.LockoutPolicyChangedEvent)
case *policy.LockoutPolicyAddedEvent, *policy.LockoutPolicyChangedEvent:
rm.LockoutPolicyReadModel.AppendEvents(e)
}
}
}

111
internal/query/idp_config_model.go
View File

@@ -1,111 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/idpconfig"
)
type IDPConfigReadModel struct {
eventstore.ReadModel
State domain.IDPConfigState
ConfigID string
Name string
AutoRegister bool
StylingType domain.IDPConfigStylingType
ProviderType domain.IdentityProviderType
OIDCConfig *OIDCConfigReadModel
JWTConfig *JWTConfigReadModel
}
func NewIDPConfigReadModel(configID string) *IDPConfigReadModel {
return &IDPConfigReadModel{
ConfigID: configID,
}
}
func (rm *IDPConfigReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *idpconfig.IDPConfigAddedEvent:
rm.ReadModel.AppendEvents(e)
case *idpconfig.IDPConfigChangedEvent:
rm.ReadModel.AppendEvents(e)
case *idpconfig.IDPConfigDeactivatedEvent:
rm.ReadModel.AppendEvents(e)
case *idpconfig.IDPConfigReactivatedEvent:
rm.ReadModel.AppendEvents(e)
case *idpconfig.IDPConfigRemovedEvent:
rm.ReadModel.AppendEvents(e)
case *idpconfig.OIDCConfigAddedEvent:
rm.OIDCConfig = &OIDCConfigReadModel{}
rm.ReadModel.AppendEvents(e)
rm.OIDCConfig.AppendEvents(event)
case *idpconfig.OIDCConfigChangedEvent:
rm.ReadModel.AppendEvents(e)
rm.OIDCConfig.AppendEvents(event)
case *idpconfig.JWTConfigAddedEvent:
rm.JWTConfig = &JWTConfigReadModel{}
rm.ReadModel.AppendEvents(e)
rm.JWTConfig.AppendEvents(event)
case *idpconfig.JWTConfigChangedEvent:
rm.ReadModel.AppendEvents(e)
rm.JWTConfig.AppendEvents(event)
}
}
}
func (rm *IDPConfigReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *idpconfig.IDPConfigAddedEvent:
rm.reduceConfigAddedEvent(e)
case *idpconfig.IDPConfigChangedEvent:
rm.reduceConfigChangedEvent(e)
case *idpconfig.IDPConfigDeactivatedEvent:
rm.reduceConfigStateChanged(e.ConfigID, domain.IDPConfigStateInactive)
case *idpconfig.IDPConfigReactivatedEvent:
rm.reduceConfigStateChanged(e.ConfigID, domain.IDPConfigStateActive)
case *idpconfig.IDPConfigRemovedEvent:
rm.reduceConfigStateChanged(e.ConfigID, domain.IDPConfigStateRemoved)
}
}
if rm.OIDCConfig != nil {
if err := rm.OIDCConfig.Reduce(); err != nil {
return err
}
}
if rm.JWTConfig != nil {
if err := rm.JWTConfig.Reduce(); err != nil {
return err
}
}
return rm.ReadModel.Reduce()
}
func (rm *IDPConfigReadModel) reduceConfigAddedEvent(e *idpconfig.IDPConfigAddedEvent) {
rm.ConfigID = e.ConfigID
rm.Name = e.Name
rm.StylingType = e.StylingType
rm.State = domain.IDPConfigStateActive
rm.AutoRegister = e.AutoRegister
}
func (rm *IDPConfigReadModel) reduceConfigChangedEvent(e *idpconfig.IDPConfigChangedEvent) {
if e.Name != nil {
rm.Name = *e.Name
}
if e.StylingType != nil && e.StylingType.Valid() {
rm.StylingType = *e.StylingType
}
if e.AutoRegister != nil {
rm.AutoRegister = *e.AutoRegister
}
}
func (rm *IDPConfigReadModel) reduceConfigStateChanged(configID string, state domain.IDPConfigState) {
rm.State = state
}

64
internal/query/idp_configs_model.go
View File

@@ -1,64 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/idpconfig"
)
type IDPConfigsReadModel struct {
eventstore.ReadModel
Configs []*IDPConfigReadModel
}
func (rm *IDPConfigsReadModel) ConfigByID(id string) (idx int, config *IDPConfigReadModel) {
for idx, config = range rm.Configs {
if config.ConfigID == id {
return idx, config
}
}
return -1, nil
}
func (rm *IDPConfigsReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *idpconfig.IDPConfigAddedEvent:
config := NewIDPConfigReadModel(e.ConfigID)
rm.Configs = append(rm.Configs, config)
config.AppendEvents(event)
case *idpconfig.IDPConfigChangedEvent:
_, config := rm.ConfigByID(e.ConfigID)
config.AppendEvents(e)
case *idpconfig.IDPConfigDeactivatedEvent:
_, config := rm.ConfigByID(e.ConfigID)
config.AppendEvents(e)
case *idpconfig.IDPConfigReactivatedEvent:
_, config := rm.ConfigByID(e.ConfigID)
config.AppendEvents(e)
case *idpconfig.OIDCConfigAddedEvent:
_, config := rm.ConfigByID(e.IDPConfigID)
config.AppendEvents(e)
case *idpconfig.OIDCConfigChangedEvent:
_, config := rm.ConfigByID(e.IDPConfigID)
config.AppendEvents(e)
case *idpconfig.IDPConfigRemovedEvent:
idx, _ := rm.ConfigByID(e.ConfigID)
if idx < 0 {
continue
}
copy(rm.Configs[idx:], rm.Configs[idx+1:])
rm.Configs[len(rm.Configs)-1] = nil
rm.Configs = rm.Configs[:len(rm.Configs)-1]
}
}
}
func (rm *IDPConfigsReadModel) Reduce() error {
for _, config := range rm.Configs {
if err := config.Reduce(); err != nil {
return err
}
}
return nil
}

47
internal/query/jwt_config_model.go
View File

@@ -1,47 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/idpconfig"
)
type JWTConfigReadModel struct {
eventstore.ReadModel
IDPConfigID string
JWTEndpoint string
Issuer string
KeysEndpoint string
}
func (rm *JWTConfigReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *idpconfig.JWTConfigAddedEvent:
rm.reduceConfigAddedEvent(e)
case *idpconfig.JWTConfigChangedEvent:
rm.reduceConfigChangedEvent(e)
}
}
return rm.ReadModel.Reduce()
}
func (rm *JWTConfigReadModel) reduceConfigAddedEvent(e *idpconfig.JWTConfigAddedEvent) {
rm.IDPConfigID = e.IDPConfigID
rm.JWTEndpoint = e.JWTEndpoint
rm.Issuer = e.Issuer
rm.KeysEndpoint = e.KeysEndpoint
}
func (rm *JWTConfigReadModel) reduceConfigChangedEvent(e *idpconfig.JWTConfigChangedEvent) {
if e.JWTEndpoint != nil {
rm.JWTEndpoint = *e.JWTEndpoint
}
if e.Issuer != nil {
rm.Issuer = *e.Issuer
}
if e.KeysEndpoint != nil {
rm.KeysEndpoint = *e.KeysEndpoint
}
}

15
internal/query/member.go
View File

@@ -1,11 +1,9 @@
package query
import (
"context"
"time"
"github.com/caos/zitadel/internal/query/projection"
"github.com/caos/zitadel/internal/telemetry/tracing"
sq "github.com/Masterminds/squirrel"
)
@@ -63,19 +61,6 @@ type Member struct {
AvatarURL string
}
func (r *Queries) IAMMemberByID(ctx context.Context, iamID, userID string) (member *IAMMemberReadModel, err error) {
ctx, span := tracing.NewSpan(ctx)
defer func() { span.EndWithError(err) }()
member = NewIAMMemberReadModel(iamID, userID)
err = r.eventstore.FilterToQueryReducer(ctx, member)
if err != nil {
return nil, err
}
return member, nil
}
var (
memberTableAlias = table{
name: "members",

35
internal/query/member_model.go
View File

@@ -1,35 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/member"
)
//MemberReadModel represenets the default member view.
// It's computed from events.
type MemberReadModel struct {
eventstore.ReadModel
UserID string
Roles []string
}
//NewMemberReadModel is the default constructor of MemberReadModel
func NewMemberReadModel(userID string) *MemberReadModel {
return &MemberReadModel{
UserID: userID,
}
}
//Reduce extends eventstore.MemberReadModel
func (rm *MemberReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *member.MemberAddedEvent:
rm.Roles = e.Roles
case *member.MemberChangedEvent:
rm.Roles = e.Roles
}
}
return rm.ReadModel.Reduce()
}

60
internal/query/member_roles.go Normal file
View File

@@ -0,0 +1,60 @@
package query
import (
"context"
"strings"
"github.com/caos/zitadel/internal/api/authz"
"github.com/caos/zitadel/internal/domain"
)
func (q *Queries) GetIAMMemberRoles() []string {
roles := make([]string, 0)
for _, roleMap := range q.zitadelRoles {
if strings.HasPrefix(roleMap.Role, "IAM") {
roles = append(roles, roleMap.Role)
}
}
return roles
}
func (q *Queries) GetOrgMemberRoles(isGlobal bool) []string {
roles := make([]string, 0)
for _, roleMap := range q.zitadelRoles {
if strings.HasPrefix(roleMap.Role, "ORG") {
roles = append(roles, roleMap.Role)
}
}
if isGlobal {
roles = append(roles, domain.RoleSelfManagementGlobal)
}
return roles
}
func (q *Queries) GetProjectMemberRoles(ctx context.Context) ([]string, error) {
iam, err := q.IAMByID(ctx, domain.IAMID)
if err != nil {
return nil, err
}
roles := make([]string, 0)
global := authz.GetCtxData(ctx).OrgID == iam.GlobalOrgID
for _, roleMap := range q.zitadelRoles {
if strings.HasPrefix(roleMap.Role, "PROJECT") && !strings.HasPrefix(roleMap.Role, "PROJECT_GRANT") {
if global && !strings.HasSuffix(roleMap.Role, "GLOBAL") {
continue
}
roles = append(roles, roleMap.Role)
}
}
return roles, nil
}
func (q *Queries) GetProjectGrantMemberRoles() []string {
roles := make([]string, 0)
for _, roleMap := range q.zitadelRoles {
if strings.HasPrefix(roleMap.Role, "PROJECT_GRANT") {
roles = append(roles, roleMap.Role)
}
}
return roles
}

53
internal/query/members_model.go
View File

@@ -1,53 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/member"
)
type MembersReadModel struct {
eventstore.ReadModel
Members []*MemberReadModel
}
func (rm *MembersReadModel) MemberByUserID(id string) (idx int, member *MemberReadModel) {
for idx, member = range rm.Members {
if member.UserID == id {
return idx, member
}
}
return -1, nil
}
func (rm *MembersReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *member.MemberAddedEvent:
m := NewMemberReadModel(e.UserID)
rm.Members = append(rm.Members, m)
m.AppendEvents(e)
case *member.MemberChangedEvent:
_, m := rm.MemberByUserID(e.UserID)
m.AppendEvents(e)
case *member.MemberRemovedEvent:
idx, _ := rm.MemberByUserID(e.UserID)
if idx < 0 {
continue
}
copy(rm.Members[idx:], rm.Members[idx+1:])
rm.Members[len(rm.Members)-1] = nil
rm.Members = rm.Members[:len(rm.Members)-1]
}
}
}
func (rm *MembersReadModel) Reduce() (err error) {
for _, m := range rm.Members {
err = m.Reduce()
if err != nil {
return err
}
}
return rm.ReadModel.Reduce()
}

71
internal/query/oidc_config_model.go
View File

@@ -1,71 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/crypto"
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/idpconfig"
)
type OIDCConfigReadModel struct {
eventstore.ReadModel
IDPConfigID string
ClientID string
ClientSecret *crypto.CryptoValue
Issuer string
AuthorizationEndpoint string
TokenEndpoint string
Scopes []string
IDPDisplayNameMapping domain.OIDCMappingField
UserNameMapping domain.OIDCMappingField
}
func (rm *OIDCConfigReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *idpconfig.OIDCConfigAddedEvent:
rm.reduceConfigAddedEvent(e)
case *idpconfig.OIDCConfigChangedEvent:
rm.reduceConfigChangedEvent(e)
}
}
return rm.ReadModel.Reduce()
}
func (rm *OIDCConfigReadModel) reduceConfigAddedEvent(e *idpconfig.OIDCConfigAddedEvent) {
rm.IDPConfigID = e.IDPConfigID
rm.ClientID = e.ClientID
rm.ClientSecret = e.ClientSecret
rm.Issuer = e.Issuer
rm.AuthorizationEndpoint = e.AuthorizationEndpoint
rm.TokenEndpoint = e.TokenEndpoint
rm.Scopes = e.Scopes
rm.IDPDisplayNameMapping = e.IDPDisplayNameMapping
rm.UserNameMapping = e.UserNameMapping
}
func (rm *OIDCConfigReadModel) reduceConfigChangedEvent(e *idpconfig.OIDCConfigChangedEvent) {
if e.ClientID != nil {
rm.ClientID = *e.ClientID
}
if e.Issuer != nil {
rm.Issuer = *e.Issuer
}
if e.AuthorizationEndpoint != nil {
rm.AuthorizationEndpoint = *e.AuthorizationEndpoint
}
if e.TokenEndpoint != nil {
rm.TokenEndpoint = *e.TokenEndpoint
}
if len(e.Scopes) > 0 {
rm.Scopes = e.Scopes
}
if e.IDPDisplayNameMapping != nil && e.IDPDisplayNameMapping.Valid() {
rm.IDPDisplayNameMapping = *e.IDPDisplayNameMapping
}
if e.UserNameMapping != nil && e.UserNameMapping.Valid() {
rm.UserNameMapping = *e.UserNameMapping
}
}

38
internal/query/org_member_model.go
View File

@@ -1,38 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/org"
)
type OrgMembersReadModel struct {
MembersReadModel
}
func (rm *OrgMembersReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *org.MemberAddedEvent:
rm.MembersReadModel.AppendEvents(&e.MemberAddedEvent)
case *org.MemberChangedEvent:
rm.MembersReadModel.AppendEvents(&e.MemberChangedEvent)
case *org.MemberRemovedEvent:
rm.MembersReadModel.AppendEvents(&e.MemberRemovedEvent)
case *org.MemberCascadeRemovedEvent:
rm.MembersReadModel.AppendEvents(&e.MemberCascadeRemovedEvent)
}
}
}
type OrgMemberReadModel MemberReadModel
func (rm *OrgMemberReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *org.MemberAddedEvent:
rm.ReadModel.AppendEvents(&e.MemberAddedEvent)
case *org.MemberChangedEvent:
rm.ReadModel.AppendEvents(&e.MemberChangedEvent)
}
}
}

22
internal/query/org_policy_label_model.go
View File

@@ -1,22 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/repository/policy"
)
type OrgLabelPolicyReadModel struct{ LabelPolicyReadModel }
func (rm *OrgLabelPolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *org.LabelPolicyAddedEvent:
rm.LabelPolicyReadModel.AppendEvents(&e.LabelPolicyAddedEvent)
case *org.LabelPolicyChangedEvent:
rm.LabelPolicyReadModel.AppendEvents(&e.LabelPolicyChangedEvent)
case *policy.LabelPolicyAddedEvent, *policy.LabelPolicyChangedEvent:
rm.LabelPolicyReadModel.AppendEvents(e)
}
}
}

22
internal/query/org_policy_login_model.go
View File

@@ -1,22 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/repository/policy"
)
type OrgLoginPolicyReadModel struct{ LoginPolicyReadModel }
func (rm *OrgLoginPolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *org.LoginPolicyAddedEvent:
rm.LoginPolicyReadModel.AppendEvents(&e.LoginPolicyAddedEvent)
case *org.LoginPolicyChangedEvent:
rm.LoginPolicyReadModel.AppendEvents(&e.LoginPolicyChangedEvent)
case *policy.LoginPolicyAddedEvent, *policy.LoginPolicyChangedEvent:
rm.LoginPolicyReadModel.AppendEvents(e)
}
}
}

20
internal/query/org_policy_org_iam_model.go
View File

@@ -1,20 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/repository/policy"
)
type OrgOrgIAMPolicyReadModel struct{ OrgIAMPolicyReadModel }
func (rm *OrgOrgIAMPolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *org.OrgIAMPolicyAddedEvent:
rm.OrgIAMPolicyReadModel.AppendEvents(&e.OrgIAMPolicyAddedEvent)
case *policy.OrgIAMPolicyAddedEvent:
rm.OrgIAMPolicyReadModel.AppendEvents(e)
}
}
}

24
internal/query/org_policy_password_age_model.go
View File

@@ -1,24 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/repository/policy"
)
type OrgPasswordAgePolicyReadModel struct {
PasswordAgePolicyReadModel
}
func (rm *OrgPasswordAgePolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *org.PasswordAgePolicyAddedEvent:
rm.PasswordAgePolicyReadModel.AppendEvents(&e.PasswordAgePolicyAddedEvent)
case *org.PasswordAgePolicyChangedEvent:
rm.PasswordAgePolicyReadModel.AppendEvents(&e.PasswordAgePolicyChangedEvent)
case *policy.PasswordAgePolicyAddedEvent, *policy.PasswordAgePolicyChangedEvent:
rm.PasswordAgePolicyReadModel.AppendEvents(e)
}
}
}

24
internal/query/org_policy_password_complexity_model.go
View File

@@ -1,24 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/repository/policy"
)
type OrgPasswordComplexityPolicyReadModel struct {
PasswordComplexityPolicyReadModel
}
func (rm *OrgPasswordComplexityPolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *org.PasswordComplexityPolicyAddedEvent:
rm.PasswordComplexityPolicyReadModel.AppendEvents(&e.PasswordComplexityPolicyAddedEvent)
case *org.PasswordComplexityPolicyChangedEvent:
rm.PasswordComplexityPolicyReadModel.AppendEvents(&e.PasswordComplexityPolicyChangedEvent)
case *policy.PasswordComplexityPolicyAddedEvent, *policy.PasswordComplexityPolicyChangedEvent:
rm.PasswordComplexityPolicyReadModel.AppendEvents(e)
}
}
}

24
internal/query/org_policy_password_lockout_model.go
View File

@@ -1,24 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/org"
"github.com/caos/zitadel/internal/repository/policy"
)
type OrgPasswordLockoutPolicyReadModel struct {
LockoutPolicyReadModel
}
func (rm *OrgPasswordLockoutPolicyReadModel) AppendEvents(events ...eventstore.Event) {
for _, event := range events {
switch e := event.(type) {
case *org.LockoutPolicyAddedEvent:
rm.LockoutPolicyReadModel.AppendEvents(&e.LockoutPolicyAddedEvent)
case *org.LockoutPolicyChangedEvent:
rm.LockoutPolicyReadModel.AppendEvents(&e.LockoutPolicyChangedEvent)
case *policy.LockoutPolicyAddedEvent, *policy.LockoutPolicyChangedEvent:
rm.LockoutPolicyReadModel.AppendEvents(e)
}
}
}

65
internal/query/policy_label_model.go
View File

@@ -1,65 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/policy"
)
type LabelPolicyReadModel struct {
eventstore.ReadModel
PrimaryColor string
BackgroundColor string
WarnColor string
FontColor string
PrimaryColorDark string
BackgroundColorDark string
WarnColorDark string
FontColorDark string
IsActive bool
}
func (rm *LabelPolicyReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *policy.LabelPolicyAddedEvent:
rm.PrimaryColor = e.PrimaryColor
rm.BackgroundColor = e.BackgroundColor
rm.FontColor = e.FontColor
rm.WarnColor = e.WarnColor
rm.PrimaryColorDark = e.PrimaryColorDark
rm.BackgroundColorDark = e.BackgroundColorDark
rm.FontColorDark = e.FontColorDark
rm.WarnColorDark = e.WarnColorDark
rm.IsActive = true
case *policy.LabelPolicyChangedEvent:
if e.PrimaryColor != nil {
rm.PrimaryColor = *e.PrimaryColor
}
if e.BackgroundColor != nil {
rm.BackgroundColor = *e.BackgroundColor
}
if e.WarnColor != nil {
rm.WarnColor = *e.WarnColor
}
if e.FontColor != nil {
rm.FontColor = *e.FontColor
}
if e.PrimaryColorDark != nil {
rm.PrimaryColorDark = *e.PrimaryColorDark
}
if e.BackgroundColorDark != nil {
rm.BackgroundColorDark = *e.BackgroundColorDark
}
if e.WarnColorDark != nil {
rm.WarnColorDark = *e.WarnColorDark
}
if e.FontColorDark != nil {
rm.FontColorDark = *e.FontColorDark
}
case *policy.LabelPolicyRemovedEvent:
rm.IsActive = false
}
}
return rm.ReadModel.Reduce()
}

51
internal/query/policy_login_model.go
View File

@@ -1,51 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/policy"
)
type LoginPolicyReadModel struct {
eventstore.ReadModel
AllowUserNamePassword bool
AllowRegister bool
AllowExternalIDP bool
ForceMFA bool
PasswordlessType domain.PasswordlessType
IsActive bool
}
func (rm *LoginPolicyReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *policy.LoginPolicyAddedEvent:
rm.AllowUserNamePassword = e.AllowUserNamePassword
rm.AllowExternalIDP = e.AllowExternalIDP
rm.AllowRegister = e.AllowRegister
rm.ForceMFA = e.ForceMFA
rm.PasswordlessType = e.PasswordlessType
rm.IsActive = true
case *policy.LoginPolicyChangedEvent:
if e.AllowUserNamePassword != nil {
rm.AllowUserNamePassword = *e.AllowUserNamePassword
}
if e.AllowExternalIDP != nil {
rm.AllowExternalIDP = *e.AllowExternalIDP
}
if e.AllowRegister != nil {
rm.AllowRegister = *e.AllowRegister
}
if e.ForceMFA != nil {
rm.ForceMFA = *e.ForceMFA
}
if e.PasswordlessType != nil {
rm.PasswordlessType = *e.PasswordlessType
}
case *policy.LoginPolicyRemovedEvent:
rm.IsActive = false
}
}
return rm.ReadModel.Reduce()
}

26
internal/query/policy_org_iam_model.go
View File

@@ -1,26 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/policy"
)
type OrgIAMPolicyReadModel struct {
eventstore.ReadModel
UserLoginMustBeDomain bool
}
func (rm *OrgIAMPolicyReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *policy.OrgIAMPolicyAddedEvent:
rm.UserLoginMustBeDomain = e.UserLoginMustBeDomain
case *policy.OrgIAMPolicyChangedEvent:
if e.UserLoginMustBeDomain != nil {
rm.UserLoginMustBeDomain = *e.UserLoginMustBeDomain
}
}
}
return rm.ReadModel.Reduce()
}

31
internal/query/policy_password_age_model.go
View File

@@ -1,31 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/policy"
)
type PasswordAgePolicyReadModel struct {
eventstore.ReadModel
ExpireWarnDays uint64
MaxAgeDays uint64
}
func (rm *PasswordAgePolicyReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *policy.PasswordAgePolicyAddedEvent:
rm.ExpireWarnDays = e.ExpireWarnDays
rm.MaxAgeDays = e.MaxAgeDays
case *policy.PasswordAgePolicyChangedEvent:
if e.ExpireWarnDays != nil {
rm.ExpireWarnDays = *e.ExpireWarnDays
}
if e.MaxAgeDays != nil {
rm.MaxAgeDays = *e.MaxAgeDays
}
}
}
return rm.ReadModel.Reduce()
}

46
internal/query/policy_password_complexity_model.go
View File

@@ -1,46 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/policy"
)
type PasswordComplexityPolicyReadModel struct {
eventstore.ReadModel
MinLength uint64
HasLowercase bool
HasUpperCase bool
HasNumber bool
HasSymbol bool
}
func (rm *PasswordComplexityPolicyReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *policy.PasswordComplexityPolicyAddedEvent:
rm.MinLength = e.MinLength
rm.HasLowercase = e.HasLowercase
rm.HasUpperCase = e.HasUppercase
rm.HasNumber = e.HasNumber
rm.HasSymbol = e.HasSymbol
case *policy.PasswordComplexityPolicyChangedEvent:
if e.MinLength != nil {
rm.MinLength = *e.MinLength
}
if e.HasLowercase != nil {
rm.HasLowercase = *e.HasLowercase
}
if e.HasUppercase != nil {
rm.HasUpperCase = *e.HasUppercase
}
if e.HasNumber != nil {
rm.HasNumber = *e.HasNumber
}
if e.HasSymbol != nil {
rm.HasSymbol = *e.HasSymbol
}
}
}
return rm.ReadModel.Reduce()
}

31
internal/query/policy_password_lockout_model.go
View File

@@ -1,31 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/policy"
)
type LockoutPolicyReadModel struct {
eventstore.ReadModel
MaxAttempts uint64
ShowLockOutFailures bool
}
func (rm *LockoutPolicyReadModel) Reduce() error {
for _, event := range rm.Events {
switch e := event.(type) {
case *policy.LockoutPolicyAddedEvent:
rm.MaxAttempts = e.MaxPasswordAttempts
rm.ShowLockOutFailures = e.ShowLockOutFailures
case *policy.LockoutPolicyChangedEvent:
if e.MaxPasswordAttempts != nil {
rm.MaxAttempts = *e.MaxPasswordAttempts
}
if e.ShowLockOutFailures != nil {
rm.ShowLockOutFailures = *e.ShowLockOutFailures
}
}
}
return rm.ReadModel.Reduce()
}

10
internal/query/query.go
View File

@@ -7,6 +7,10 @@ import (
"sync"
"github.com/caos/logging"
"github.com/rakyll/statik/fs"
"golang.org/x/text/language"
"github.com/caos/zitadel/internal/api/authz"
sd "github.com/caos/zitadel/internal/config/systemdefaults"
"github.com/caos/zitadel/internal/config/types"
"github.com/caos/zitadel/internal/eventstore"
@@ -18,8 +22,6 @@ import (
"github.com/caos/zitadel/internal/repository/project"
usr_repo "github.com/caos/zitadel/internal/repository/user"
"github.com/caos/zitadel/internal/repository/usergrant"
"github.com/rakyll/statik/fs"
"golang.org/x/text/language"
)
type Queries struct {
@@ -34,13 +36,14 @@ type Queries struct {
LoginTranslationFileContents map[string][]byte
NotificationTranslationFileContents map[string][]byte
supportedLangs []language.Tag
zitadelRoles []authz.RoleMapping
}
type Config struct {
Eventstore types.SQLUser
}
func StartQueries(ctx context.Context, es *eventstore.Eventstore, projections projection.Config, defaults sd.SystemDefaults, keyChan chan<- interface{}) (repo *Queries, err error) {
func StartQueries(ctx context.Context, es *eventstore.Eventstore, projections projection.Config, defaults sd.SystemDefaults, keyChan chan<- interface{}, zitadelRoles []authz.RoleMapping) (repo *Queries, err error) {
sqlClient, err := projections.CRDB.Start()
if err != nil {
return nil, err
@@ -61,6 +64,7 @@ func StartQueries(ctx context.Context, es *eventstore.Eventstore, projections pr
NotificationDir: statikNotificationFS,
LoginTranslationFileContents: make(map[string][]byte),
NotificationTranslationFileContents: make(map[string][]byte),
zitadelRoles: zitadelRoles,
}
iam_repo.RegisterEventMappers(repo.eventstore)
usr_repo.RegisterEventMappers(repo.eventstore)

6
internal/query/user.go
View File

@@ -13,7 +13,6 @@ import (
"github.com/caos/zitadel/internal/domain"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/query/projection"
)
@@ -354,11 +353,6 @@ func (q *Queries) IsUserUnique(ctx context.Context, username, email, resourceOwn
return scan(row)
}
func (q *Queries) UserEvents(ctx context.Context, orgID, userID string, sequence uint64) ([]eventstore.Event, error) {
query := NewUserEventSearchQuery(userID, orgID, sequence)
return q.eventstore.Filter(ctx, query)
}
func (q *UserSearchQueries) toQuery(query sq.SelectBuilder) sq.SelectBuilder {
query = q.SearchRequest.toQuery(query)
for _, q := range q.Queries {

6
internal/query/user_grant.go
View File

@@ -185,14 +185,12 @@ var (
}
)
func (q *Queries) UserGrantByID(ctx context.Context, id string, queries ...SearchQuery) (*UserGrant, error) {
func (q *Queries) UserGrant(ctx context.Context, queries ...SearchQuery) (*UserGrant, error) {
query, scan := prepareUserGrantQuery()
for _, q := range queries {
query = q.toQuery(query)
}
stmt, args, err := query.Where(sq.Eq{
UserGrantID.identifier(): id,
}).ToSql()
stmt, args, err := query.ToSql()
if err != nil {
return nil, errors.ThrowInternal(err, "QUERY-Fa1KW", "Errors.Query.SQLStatement")
}

67
internal/query/user_model.go
View File

@@ -1,67 +0,0 @@
package query
import (
"github.com/caos/zitadel/internal/eventstore"
"github.com/caos/zitadel/internal/repository/user"
)
type UserReadModel struct {
eventstore.ReadModel
}
func NewUserReadModel(id string) *UserReadModel {
return &UserReadModel{
ReadModel: eventstore.ReadModel{
AggregateID: id,
},
}
}
func (rm *UserReadModel) AppendEvents(events ...eventstore.Event) {
rm.ReadModel.AppendEvents(events...)
for _, event := range events {
switch event.(type) {
// TODO: implement append events
}
}
}
func (rm *UserReadModel) Reduce() (err error) {
for _, event := range rm.Events {
switch event.(type) {
//TODO: implement reduce
}
}
for _, reduce := range []func() error{
rm.ReadModel.Reduce,
} {
if err = reduce(); err != nil {
return err
}
}
return nil
}
func (rm *UserReadModel) AppendAndReduce(events ...eventstore.Event) error {
rm.AppendEvents(events...)
return rm.Reduce()
}
func (rm *UserReadModel) Query() *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
AddQuery().
AggregateTypes(user.AggregateType).
AggregateIDs(rm.AggregateID).
Builder()
}
func NewUserEventSearchQuery(userID, orgID string, sequence uint64) *eventstore.SearchQueryBuilder {
return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
ResourceOwner(orgID).
AddQuery().
AggregateTypes(user.AggregateType).
AggregateIDs(userID).
SequenceGreater(sequence).
Builder()
}

42
internal/query/zitadel_permission.go Normal file
View File

@@ -0,0 +1,42 @@
package query
import (
"context"
"github.com/caos/zitadel/internal/domain"
)
func (q *Queries) MyZitadelPermissions(ctx context.Context, userID string) (*domain.Permissions, error) {
userIDQuery, err := NewMembershipUserIDQuery(userID)
if err != nil {
return nil, err
}
memberships, err := q.Memberships(ctx, &MembershipSearchQuery{
Queries: []SearchQuery{userIDQuery},
})
if err != nil {
return nil, err
}
permissions := &domain.Permissions{Permissions: []string{}}
for _, membership := range memberships.Memberships {
for _, role := range membership.Roles {
permissions = q.mapRoleToPermission(permissions, membership, role)
}
}
return permissions, nil
}
func (q *Queries) mapRoleToPermission(permissions *domain.Permissions, membership *Membership, role string) *domain.Permissions {
for _, mapping := range q.zitadelRoles {
if mapping.Role == role {
ctxID := ""
if membership.Project != nil {
ctxID = membership.Project.ProjectID
} else if membership.ProjectGrant != nil {
ctxID = membership.ProjectGrant.GrantID
}
permissions.AppendPermissions(ctxID, mapping.Permissions...)
}
}
return permissions
}