mirror of
https://github.com/zitadel/zitadel.git
synced 2024-12-12 11:04:25 +00:00
f1fa74a2c0
* fix: loginnames in login and mails (eventstore v1 queries) * fix: loginnames in login and mails (eventstore v1 queries)
295 lines
8.7 KiB
Go
295 lines
8.7 KiB
Go
package handler
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/zitadel/logging"
|
|
|
|
"github.com/zitadel/zitadel/internal/errors"
|
|
"github.com/zitadel/zitadel/internal/eventstore"
|
|
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
|
|
es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
|
|
"github.com/zitadel/zitadel/internal/eventstore/v1/query"
|
|
es_sdk "github.com/zitadel/zitadel/internal/eventstore/v1/sdk"
|
|
"github.com/zitadel/zitadel/internal/eventstore/v1/spooler"
|
|
org_model "github.com/zitadel/zitadel/internal/org/model"
|
|
org_es_model "github.com/zitadel/zitadel/internal/org/repository/eventsourcing/model"
|
|
"github.com/zitadel/zitadel/internal/org/repository/view"
|
|
query2 "github.com/zitadel/zitadel/internal/query"
|
|
"github.com/zitadel/zitadel/internal/repository/org"
|
|
user_repo "github.com/zitadel/zitadel/internal/repository/user"
|
|
view_model "github.com/zitadel/zitadel/internal/user/repository/view/model"
|
|
)
|
|
|
|
const (
|
|
userTable = "auth.users"
|
|
)
|
|
|
|
type User struct {
|
|
handler
|
|
subscription *v1.Subscription
|
|
queries *query2.Queries
|
|
}
|
|
|
|
func newUser(
|
|
handler handler,
|
|
queries *query2.Queries,
|
|
) *User {
|
|
h := &User{
|
|
handler: handler,
|
|
queries: queries,
|
|
}
|
|
|
|
h.subscribe()
|
|
|
|
return h
|
|
}
|
|
|
|
func (k *User) subscribe() {
|
|
k.subscription = k.es.Subscribe(k.AggregateTypes()...)
|
|
go func() {
|
|
for event := range k.subscription.Events {
|
|
query.ReduceEvent(k, event)
|
|
}
|
|
}()
|
|
}
|
|
|
|
func (u *User) ViewModel() string {
|
|
return userTable
|
|
}
|
|
|
|
func (u *User) Subscription() *v1.Subscription {
|
|
return u.subscription
|
|
}
|
|
func (_ *User) AggregateTypes() []es_models.AggregateType {
|
|
return []es_models.AggregateType{user_repo.AggregateType, org.AggregateType}
|
|
}
|
|
|
|
func (u *User) CurrentSequence(instanceID string) (uint64, error) {
|
|
sequence, err := u.view.GetLatestUserSequence(instanceID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return sequence.CurrentSequence, nil
|
|
}
|
|
|
|
func (u *User) EventQuery() (*es_models.SearchQuery, error) {
|
|
sequences, err := u.view.GetLatestUserSequences()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
query := es_models.NewSearchQuery()
|
|
instances := make([]string, 0)
|
|
for _, sequence := range sequences {
|
|
for _, instance := range instances {
|
|
if sequence.InstanceID == instance {
|
|
break
|
|
}
|
|
}
|
|
instances = append(instances, sequence.InstanceID)
|
|
query.AddQuery().
|
|
AggregateTypeFilter(u.AggregateTypes()...).
|
|
LatestSequenceFilter(sequence.CurrentSequence).
|
|
InstanceIDFilter(sequence.InstanceID)
|
|
}
|
|
return query.AddQuery().
|
|
AggregateTypeFilter(u.AggregateTypes()...).
|
|
LatestSequenceFilter(0).
|
|
ExcludedInstanceIDsFilter(instances...).
|
|
SearchQuery(), nil
|
|
}
|
|
|
|
func (u *User) Reduce(event *es_models.Event) (err error) {
|
|
switch event.AggregateType {
|
|
case user_repo.AggregateType:
|
|
return u.ProcessUser(event)
|
|
case org.AggregateType:
|
|
return u.ProcessOrg(event)
|
|
default:
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func (u *User) ProcessUser(event *es_models.Event) (err error) {
|
|
user := new(view_model.UserView)
|
|
switch eventstore.EventType(event.Type) {
|
|
case user_repo.UserV1AddedType,
|
|
user_repo.MachineAddedEventType,
|
|
user_repo.HumanAddedType,
|
|
user_repo.UserV1RegisteredType,
|
|
user_repo.HumanRegisteredType:
|
|
err = user.AppendEvent(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = u.fillLoginNames(user)
|
|
case user_repo.UserV1ProfileChangedType,
|
|
user_repo.UserV1EmailChangedType,
|
|
user_repo.UserV1EmailVerifiedType,
|
|
user_repo.UserV1PhoneChangedType,
|
|
user_repo.UserV1PhoneVerifiedType,
|
|
user_repo.UserV1PhoneRemovedType,
|
|
user_repo.UserV1AddressChangedType,
|
|
user_repo.UserDeactivatedType,
|
|
user_repo.UserReactivatedType,
|
|
user_repo.UserLockedType,
|
|
user_repo.UserUnlockedType,
|
|
user_repo.UserV1MFAOTPAddedType,
|
|
user_repo.UserV1MFAOTPVerifiedType,
|
|
user_repo.UserV1MFAOTPRemovedType,
|
|
user_repo.UserV1MFAInitSkippedType,
|
|
user_repo.UserV1PasswordChangedType,
|
|
user_repo.HumanProfileChangedType,
|
|
user_repo.HumanEmailChangedType,
|
|
user_repo.HumanEmailVerifiedType,
|
|
user_repo.HumanAvatarAddedType,
|
|
user_repo.HumanAvatarRemovedType,
|
|
user_repo.HumanPhoneChangedType,
|
|
user_repo.HumanPhoneVerifiedType,
|
|
user_repo.HumanPhoneRemovedType,
|
|
user_repo.HumanAddressChangedType,
|
|
user_repo.HumanMFAOTPAddedType,
|
|
user_repo.HumanMFAOTPVerifiedType,
|
|
user_repo.HumanMFAOTPRemovedType,
|
|
user_repo.HumanU2FTokenAddedType,
|
|
user_repo.HumanU2FTokenVerifiedType,
|
|
user_repo.HumanU2FTokenRemovedType,
|
|
user_repo.HumanPasswordlessTokenAddedType,
|
|
user_repo.HumanPasswordlessTokenVerifiedType,
|
|
user_repo.HumanPasswordlessTokenRemovedType,
|
|
user_repo.HumanMFAInitSkippedType,
|
|
user_repo.MachineChangedEventType,
|
|
user_repo.HumanPasswordChangedType,
|
|
user_repo.HumanPasswordlessInitCodeAddedType,
|
|
user_repo.HumanPasswordlessInitCodeRequestedType:
|
|
user, err = u.view.UserByID(event.AggregateID, event.InstanceID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = user.AppendEvent(event)
|
|
case user_repo.UserDomainClaimedType,
|
|
user_repo.UserUserNameChangedType:
|
|
user, err = u.view.UserByID(event.AggregateID, event.InstanceID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = user.AppendEvent(event)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = u.fillLoginNames(user)
|
|
case user_repo.UserRemovedType:
|
|
return u.view.DeleteUser(event.AggregateID, event.InstanceID, event)
|
|
default:
|
|
return u.view.ProcessedUserSequence(event)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return u.view.PutUser(user, event)
|
|
}
|
|
|
|
func (u *User) fillLoginNames(user *view_model.UserView) (err error) {
|
|
userLoginMustBeDomain, primaryDomain, domains, err := u.loginNameInformation(context.Background(), user.ResourceOwner, user.InstanceID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
user.SetLoginNames(userLoginMustBeDomain, domains)
|
|
user.PreferredLoginName = user.GenerateLoginName(primaryDomain, userLoginMustBeDomain)
|
|
return nil
|
|
}
|
|
|
|
func (u *User) ProcessOrg(event *es_models.Event) (err error) {
|
|
switch eventstore.EventType(event.Type) {
|
|
case org.OrgDomainVerifiedEventType,
|
|
org.OrgDomainRemovedEventType,
|
|
org.DomainPolicyAddedEventType,
|
|
org.DomainPolicyChangedEventType,
|
|
org.DomainPolicyRemovedEventType:
|
|
return u.fillLoginNamesOnOrgUsers(event)
|
|
case org.OrgDomainPrimarySetEventType:
|
|
return u.fillPreferredLoginNamesOnOrgUsers(event)
|
|
default:
|
|
return u.view.ProcessedUserSequence(event)
|
|
}
|
|
}
|
|
|
|
func (u *User) fillLoginNamesOnOrgUsers(event *es_models.Event) error {
|
|
userLoginMustBeDomain, _, domains, err := u.loginNameInformation(context.Background(), event.ResourceOwner, event.InstanceID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
users, err := u.view.UsersByOrgID(event.AggregateID, event.InstanceID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, user := range users {
|
|
user.SetLoginNames(userLoginMustBeDomain, domains)
|
|
}
|
|
return u.view.PutUsers(users, event)
|
|
}
|
|
|
|
func (u *User) fillPreferredLoginNamesOnOrgUsers(event *es_models.Event) error {
|
|
userLoginMustBeDomain, primaryDomain, _, err := u.loginNameInformation(context.Background(), event.ResourceOwner, event.InstanceID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !userLoginMustBeDomain {
|
|
return nil
|
|
}
|
|
users, err := u.view.UsersByOrgID(event.AggregateID, event.InstanceID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, user := range users {
|
|
user.PreferredLoginName = user.GenerateLoginName(primaryDomain, userLoginMustBeDomain)
|
|
}
|
|
return u.view.PutUsers(users, event)
|
|
}
|
|
|
|
func (u *User) OnError(event *es_models.Event, err error) error {
|
|
logging.LogWithFields("SPOOL-is8aAWima", "id", event.AggregateID).WithError(err).Warn("something went wrong in user handler")
|
|
return spooler.HandleError(event, err, u.view.GetLatestUserFailedEvent, u.view.ProcessedUserFailedEvent, u.view.ProcessedUserSequence, u.errorCountUntilSkip)
|
|
}
|
|
|
|
func (u *User) OnSuccess() error {
|
|
return spooler.HandleSuccess(u.view.UpdateUserSpoolerRunTimestamp)
|
|
}
|
|
|
|
func (u *User) getOrgByID(ctx context.Context, orgID, instanceID string) (*org_model.Org, error) {
|
|
query, err := view.OrgByIDQuery(orgID, instanceID, 0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
esOrg := &org_es_model.Org{
|
|
ObjectRoot: es_models.ObjectRoot{
|
|
AggregateID: orgID,
|
|
},
|
|
}
|
|
err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esOrg.AppendEvents, query)
|
|
if err != nil && !errors.IsNotFound(err) {
|
|
return nil, err
|
|
}
|
|
if esOrg.Sequence == 0 {
|
|
return nil, errors.ThrowNotFound(nil, "EVENT-3m9vs", "Errors.Org.NotFound")
|
|
}
|
|
|
|
return org_es_model.OrgToModel(esOrg), nil
|
|
}
|
|
|
|
func (u *User) loginNameInformation(ctx context.Context, orgID string, instanceID string) (userLoginMustBeDomain bool, primaryDomain string, domains []*org_model.OrgDomain, err error) {
|
|
org, err := u.getOrgByID(ctx, orgID, instanceID)
|
|
if err != nil {
|
|
return false, "", nil, err
|
|
}
|
|
if org.DomainPolicy == nil {
|
|
policy, err := u.queries.DefaultDomainPolicy(withInstanceID(ctx, org.InstanceID))
|
|
if err != nil {
|
|
return false, "", nil, err
|
|
}
|
|
userLoginMustBeDomain = policy.UserLoginMustBeDomain
|
|
}
|
|
return userLoginMustBeDomain, org.GetPrimaryDomain().Domain, org.Domains, nil
|
|
}
|