feat: user events (#1062)

* feat: user new eventstore

* feat: rename query builder

* feat: human events

* feat: human events

* feat: events

* feat: phone events

* feat: phone events

* feat: profile, address events

* feat: mfa, otp

* feat: webauthn events

* feat: webauthn events

* feat: webauthn events

* feat: enums

* feat: new events

* feat: user events

* feat: domain events

* feat: all v2 events

* feat: all v1 events

* feat: pkg structure

* feat: change events

* feat: better naming

* feat: better naming
This commit is contained in:
Fabi
2020-12-10 16:18:52 +01:00
committed by GitHub
parent 5dd60f01e0
commit 31ea9d1acd
25 changed files with 3237 additions and 3 deletions
@@ -0,0 +1,79 @@
package address
import (
"context"
"encoding/json"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/eventstore/v2/repository"
)
const (
addressEventPrefix = eventstore.EventType("user.human.address.")
HumanAddressChangedType = addressEventPrefix + "changed"
)
type ChangedEvent struct {
eventstore.BaseEvent `json:"-"`
Country string `json:"country,omitempty"`
Locality string `json:"locality,omitempty"`
PostalCode string `json:"postalCode,omitempty"`
Region string `json:"region,omitempty"`
StreetAddress string `json:"streetAddress,omitempty"`
}
func (e *ChangedEvent) CheckPrevious() bool {
return true
}
func (e *ChangedEvent) Data() interface{} {
return e
}
func NewChangedEvent(
ctx context.Context,
current *WriteModel,
country,
locality,
postalCode,
region,
streetAddress string,
) *ChangedEvent {
e := &ChangedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanAddressChangedType,
),
}
if current.Country != country {
e.Country = country
}
if current.Locality != locality {
e.Locality = locality
}
if current.PostalCode != postalCode {
e.PostalCode = postalCode
}
if current.Region != region {
e.Region = region
}
if current.StreetAddress != streetAddress {
e.StreetAddress = streetAddress
}
return e
}
func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
addressChanged := &ChangedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, addressChanged)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-5M0pd", "unable to unmarshal human address changed")
}
return addressChanged, nil
}
@@ -0,0 +1,13 @@
package address
import "github.com/caos/zitadel/internal/eventstore/v2"
type WriteModel struct {
eventstore.WriteModel
Country string
Locality string
PostalCode string
Region string
StreetAddress string
}
@@ -0,0 +1,189 @@
package email
import (
"context"
"encoding/json"
"github.com/caos/zitadel/internal/crypto"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/eventstore/v2/repository"
"time"
)
const (
emailEventPrefix = eventstore.EventType("user.human.email.")
HumanEmailChangedType = emailEventPrefix + "changed"
HumanEmailVerifiedType = emailEventPrefix + "verified"
HumanEmailVerificationFailedType = emailEventPrefix + "verification.failed"
HumanEmailCodeAddedType = emailEventPrefix + "code.added"
HumanEmailCodeSentType = emailEventPrefix + "code.sent"
)
type ChangedEvent struct {
eventstore.BaseEvent `json:"-"`
EmailAddress string `json:"email,omitempty"`
}
func (e *ChangedEvent) CheckPrevious() bool {
return true
}
func (e *ChangedEvent) Data() interface{} {
return e
}
func NewChangedEvent(
ctx context.Context,
current *WriteModel,
emailAddress string,
) *ChangedEvent {
e := &ChangedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanEmailChangedType,
),
}
if current.Email != emailAddress {
e.EmailAddress = emailAddress
}
return e
}
func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
emailChangedEvent := &ChangedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, emailChangedEvent)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-4M0sd", "unable to unmarshal human password changed")
}
return emailChangedEvent, nil
}
type VerifiedEvent struct {
eventstore.BaseEvent `json:"-"`
IsEmailVerified bool `json:"-"`
}
func (e *VerifiedEvent) CheckPrevious() bool {
return true
}
func (e *VerifiedEvent) Data() interface{} {
return nil
}
func NewVerifiedEvent(ctx context.Context) *VerifiedEvent {
return &VerifiedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanEmailVerifiedType,
),
}
}
func VerifiedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
emailVerified := &VerifiedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
IsEmailVerified: true,
}
return emailVerified, nil
}
type VerificationFailedEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *VerificationFailedEvent) CheckPrevious() bool {
return false
}
func (e *VerificationFailedEvent) Data() interface{} {
return nil
}
func NewVerificationFailedEvent(ctx context.Context) *VerificationFailedEvent {
return &VerificationFailedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanEmailVerificationFailedType,
),
}
}
func VerificationFailedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &VerificationFailedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
type CodeAddedEvent struct {
eventstore.BaseEvent `json:"-"`
Code *crypto.CryptoValue `json:"code,omitempty"`
Expiry time.Duration `json:"expiry,omitempty"`
}
func (e *CodeAddedEvent) CheckPrevious() bool {
return true
}
func (e *CodeAddedEvent) Data() interface{} {
return e
}
func NewCodeAddedEvent(
ctx context.Context,
code *crypto.CryptoValue,
expiry time.Duration) *CodeAddedEvent {
return &CodeAddedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanEmailCodeAddedType,
),
Code: code,
Expiry: expiry,
}
}
func CodeAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
codeAdded := &CodeAddedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, codeAdded)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-3M0sd", "unable to unmarshal human email code added")
}
return codeAdded, nil
}
type CodeSentEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *CodeSentEvent) CheckPrevious() bool {
return true
}
func (e *CodeSentEvent) Data() interface{} {
return nil
}
func NewCodeSentEvent(ctx context.Context) *CodeSentEvent {
return &CodeSentEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanEmailCodeSentType,
),
}
}
func CodeSentEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &CodeSentEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
@@ -0,0 +1,9 @@
package email
import "github.com/caos/zitadel/internal/eventstore/v2"
type WriteModel struct {
eventstore.WriteModel
Email string
}
+336
View File
@@ -0,0 +1,336 @@
package human
import (
"context"
"encoding/json"
"github.com/caos/zitadel/internal/crypto"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/eventstore/v2/repository"
"golang.org/x/text/language"
"time"
)
const (
humanEventPrefix = eventstore.EventType("user.human.")
HumanAddedType = humanEventPrefix + "added"
HumanRegisteredType = humanEventPrefix + "selfregistered"
HumanInitialCodeAddedType = humanEventPrefix + "initialization.code.added"
HumanInitialCodeSentType = humanEventPrefix + "initialization.code.sent"
HumanInitializedCheckSucceededType = humanEventPrefix + "initialization.check.succeeded"
HumanInitializedCheckFailedType = humanEventPrefix + "initialization.check.failed"
HumanSignedOutType = humanEventPrefix + "signed.out"
)
type AddedEvent struct {
eventstore.BaseEvent `json:"-"`
UserName string `json:"userName"`
FirstName string `json:"firstName,omitempty"`
LastName string `json:"lastName,omitempty"`
NickName string `json:"nickName,omitempty"`
DisplayName string `json:"displayName,omitempty"`
PreferredLanguage language.Tag `json:"preferredLanguage,omitempty"`
Gender Gender `json:"gender,omitempty"`
EmailAddress string `json:"email,omitempty"`
PhoneNumber string `json:"phone,omitempty"`
Country string `json:"country,omitempty"`
Locality string `json:"locality,omitempty"`
PostalCode string `json:"postalCode,omitempty"`
Region string `json:"region,omitempty"`
StreetAddress string `json:"streetAddress,omitempty"`
}
func (e *AddedEvent) CheckPrevious() bool {
return false
}
func (e *AddedEvent) Data() interface{} {
return e
}
func NewAddedEvent(
ctx context.Context,
userName,
firstName,
lastName,
nickName,
displayName string,
preferredLanguage language.Tag,
gender Gender,
emailAddress,
phoneNumber,
country,
locality,
postalCode,
region,
streetAddress string,
) *AddedEvent {
return &AddedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanAddedType,
),
UserName: userName,
FirstName: firstName,
LastName: lastName,
NickName: nickName,
DisplayName: displayName,
PreferredLanguage: preferredLanguage,
Gender: gender,
EmailAddress: emailAddress,
PhoneNumber: phoneNumber,
Country: country,
Locality: locality,
PostalCode: postalCode,
Region: region,
StreetAddress: streetAddress,
}
}
func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
humanAdded := &AddedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, humanAdded)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-5Gm9s", "unable to unmarshal human added")
}
return humanAdded, nil
}
type RegisteredEvent struct {
eventstore.BaseEvent `json:"-"`
UserName string `json:"userName"`
FirstName string `json:"firstName,omitempty"`
LastName string `json:"lastName,omitempty"`
NickName string `json:"nickName,omitempty"`
DisplayName string `json:"displayName,omitempty"`
PreferredLanguage language.Tag `json:"preferredLanguage,omitempty"`
Gender int32 `json:"gender,omitempty"`
EmailAddress string `json:"email,omitempty"`
PhoneNumber string `json:"phone,omitempty"`
Country string `json:"country,omitempty"`
Locality string `json:"locality,omitempty"`
PostalCode string `json:"postalCode,omitempty"`
Region string `json:"region,omitempty"`
StreetAddress string `json:"streetAddress,omitempty"`
}
func (e *RegisteredEvent) CheckPrevious() bool {
return false
}
func (e *RegisteredEvent) Data() interface{} {
return e
}
func NewRegisteredEvent(
ctx context.Context,
userName,
firstName,
lastName,
nickName,
displayName string,
preferredLanguage language.Tag,
gender int32,
emailAddress,
phoneNumber,
country,
locality,
postalCode,
region,
streetAddress string,
) *RegisteredEvent {
return &RegisteredEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanRegisteredType,
),
UserName: userName,
FirstName: firstName,
LastName: lastName,
NickName: nickName,
DisplayName: displayName,
PreferredLanguage: preferredLanguage,
Gender: gender,
EmailAddress: emailAddress,
PhoneNumber: phoneNumber,
Country: country,
Locality: locality,
PostalCode: postalCode,
Region: region,
StreetAddress: streetAddress,
}
}
func RegisteredEventMapper(event *repository.Event) (eventstore.EventReader, error) {
humanRegistered := &RegisteredEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, humanRegistered)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-3Vm9s", "unable to unmarshal human registered")
}
return humanRegistered, nil
}
type InitialCodeAddedEvent struct {
eventstore.BaseEvent `json:"-"`
Code *crypto.CryptoValue `json:"code,omitempty"`
Expiry time.Duration `json:"expiry,omitempty"`
}
func (e *InitialCodeAddedEvent) CheckPrevious() bool {
return true
}
func (e *InitialCodeAddedEvent) Data() interface{} {
return e
}
func NewInitialCodeAddedEvent(
ctx context.Context,
code *crypto.CryptoValue,
expiry time.Duration,
) *InitialCodeAddedEvent {
return &InitialCodeAddedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanInitialCodeAddedType,
),
Code: code,
Expiry: expiry,
}
}
func InitialCodeAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
humanRegistered := &InitialCodeAddedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, humanRegistered)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-bM9se", "unable to unmarshal human initial code added")
}
return humanRegistered, nil
}
type InitialCodeSentEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *InitialCodeSentEvent) CheckPrevious() bool {
return false
}
func (e *InitialCodeSentEvent) Data() interface{} {
return nil
}
func NewInitialCodeSentEvent(ctx context.Context) *InitialCodeSentEvent {
return &InitialCodeSentEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanInitialCodeSentType,
),
}
}
func InitialCodeSentEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &InitialCodeSentEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
type InitializedCheckSucceededEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *InitializedCheckSucceededEvent) CheckPrevious() bool {
return false
}
func (e *InitializedCheckSucceededEvent) Data() interface{} {
return nil
}
func NewInitializedCheckSucceededEvent(ctx context.Context) *InitializedCheckSucceededEvent {
return &InitializedCheckSucceededEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanInitializedCheckSucceededType,
),
}
}
func InitializedCheckSucceededEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &InitializedCheckSucceededEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
type InitializedCheckFailedEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *InitializedCheckFailedEvent) CheckPrevious() bool {
return false
}
func (e *InitializedCheckFailedEvent) Data() interface{} {
return nil
}
func NewInitializedCheckFailedEvent(ctx context.Context) *InitializedCheckFailedEvent {
return &InitializedCheckFailedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanInitializedCheckFailedType,
),
}
}
func InitializedCheckFailedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &InitializedCheckFailedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
type SignedOutEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *SignedOutEvent) CheckPrevious() bool {
return false
}
func (e *SignedOutEvent) Data() interface{} {
return nil
}
func NewSignedOutEvent(ctx context.Context) *SignedOutEvent {
return &SignedOutEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanSignedOutType,
),
}
}
func SignedOutEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &SignedOutEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
@@ -0,0 +1,206 @@
package external_idp
import (
"context"
"encoding/json"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/eventstore/v2/repository"
)
const (
externalIDPEventPrefix = eventstore.EventType("user.human.externalidp.")
externalLoginEventPrefix = eventstore.EventType("user.human.externallogin.")
//TODO: Handle unique Aggregate
HumanExternalIDPReservedType = externalIDPEventPrefix + "reserved"
HumanExternalIDPReleasedType = externalIDPEventPrefix + "released"
HumanExternalIDPAddedType = externalIDPEventPrefix + "added"
HumanExternalIDPRemovedType = externalIDPEventPrefix + "removed"
HumanExternalIDPCascadeRemovedType = externalIDPEventPrefix + "cascade.removed"
HumanExternalLoginCheckSucceededType = externalLoginEventPrefix + "check.succeeded"
)
type ReservedEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *ReservedEvent) CheckPrevious() bool {
return true
}
func (e *ReservedEvent) Data() interface{} {
return nil
}
func NewReservedEvent(ctx context.Context) *ReservedEvent {
return &ReservedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanExternalIDPReservedType,
),
}
}
type ReleasedEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *ReleasedEvent) CheckPrevious() bool {
return true
}
func (e *ReleasedEvent) Data() interface{} {
return nil
}
func NewReleasedEvent(ctx context.Context) *ReleasedEvent {
return &ReleasedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanExternalIDPReleasedType,
),
}
}
type AddedEvent struct {
eventstore.BaseEvent `json:"-"`
IDPConfigID string `json:"idpConfigId,omitempty"`
DisplayName string `json:"displayName,omitempty"`
}
func (e *AddedEvent) CheckPrevious() bool {
return true
}
func (e *AddedEvent) Data() interface{} {
return e
}
func NewAddedEvent(ctx context.Context, idpConfigID, displayName string) *AddedEvent {
return &AddedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanExternalIDPAddedType,
),
IDPConfigID: idpConfigID,
DisplayName: displayName,
}
}
func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
e := &AddedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, e)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-6M9sd", "unable to unmarshal user external idp added")
}
return e, nil
}
type RemovedEvent struct {
eventstore.BaseEvent `json:"-"`
IDPConfigID string `json:"idpConfigId"`
}
func (e *RemovedEvent) CheckPrevious() bool {
return true
}
func (e *RemovedEvent) Data() interface{} {
return e
}
func NewRemovedEvent(ctx context.Context, idpConfigID string) *RemovedEvent {
return &RemovedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanExternalIDPRemovedType,
),
IDPConfigID: idpConfigID,
}
}
func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
e := &RemovedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, e)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-5Gm9s", "unable to unmarshal user external idp removed")
}
return e, nil
}
type CascadeRemovedEvent struct {
eventstore.BaseEvent `json:"-"`
IDPConfigID string `json:"idpConfigId"`
}
func (e *CascadeRemovedEvent) CheckPrevious() bool {
return false
}
func (e *CascadeRemovedEvent) Data() interface{} {
return e
}
func NewCascadeRemovedEvent(ctx context.Context, idpConfigID string) *CascadeRemovedEvent {
return &CascadeRemovedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanExternalIDPCascadeRemovedType,
),
IDPConfigID: idpConfigID,
}
}
func CascadeRemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
e := &CascadeRemovedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, e)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-2M0sd", "unable to unmarshal user external idp cascade removed")
}
return e, nil
}
type CheckSucceededEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *CheckSucceededEvent) CheckPrevious() bool {
return false
}
func (e *CheckSucceededEvent) Data() interface{} {
return nil
}
func NewCheckSucceededEvent(ctx context.Context) *CheckSucceededEvent {
return &CheckSucceededEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanExternalLoginCheckSucceededType,
),
}
}
func CheckSucceededEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &CheckSucceededEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
@@ -0,0 +1,16 @@
package human
type Gender int32
const (
GenderUnspecified Gender = iota
GenderFemale
GenderMale
GenderDiverse
genderCount
)
func (f Gender) Valid() bool {
return f >= 0 && f < genderCount
}
@@ -0,0 +1,39 @@
package mfa
import (
"context"
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/eventstore/v2/repository"
)
const (
mfaEventPrefix = eventstore.EventType("user.human.mfa.")
HumanMFAInitSkippedType = mfaEventPrefix + "init.skiped"
)
type InitSkippedEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *InitSkippedEvent) CheckPrevious() bool {
return true
}
func (e *InitSkippedEvent) Data() interface{} {
return e
}
func NewInitSkippedEvent(ctx context.Context) *InitSkippedEvent {
return &InitSkippedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanMFAInitSkippedType,
),
}
}
func InitSkippedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &InitSkippedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
@@ -0,0 +1,15 @@
package mfa
type State int32
const (
StateUnspecified State = iota
StateNotReady
StateReady
stateCount
)
func (f State) Valid() bool {
return f >= 0 && f < stateCount
}
@@ -0,0 +1,168 @@
package otp
import (
"context"
"encoding/json"
"github.com/caos/zitadel/internal/crypto"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/eventstore/v2/repository"
"github.com/caos/zitadel/internal/v2/repository/user/human/mfa"
)
const (
otpEventPrefix = eventstore.EventType("user.human.mfa.otp.")
HumanMFAOTPAddedType = otpEventPrefix + "added"
HumanMFAOTPVerifiedType = otpEventPrefix + "verified"
HumanMFAOTPRemovedType = otpEventPrefix + "removed"
HumanMFAOTPCheckSucceededType = otpEventPrefix + "check.succeeded"
HumanMFAOTPCheckFailedType = otpEventPrefix + "check.failed"
)
type AddedEvent struct {
eventstore.BaseEvent `json:"-"`
Secret *crypto.CryptoValue `json:"otpSecret,omitempty"`
State mfa.State `json:"-"`
}
func (e *AddedEvent) CheckPrevious() bool {
return true
}
func (e *AddedEvent) Data() interface{} {
return e
}
func NewAddedEvent(ctx context.Context,
secret *crypto.CryptoValue) *AddedEvent {
return &AddedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanMFAOTPAddedType,
),
Secret: secret,
}
}
func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
otpAdded := &AddedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
State: mfa.StateNotReady,
}
err := json.Unmarshal(event.Data, otpAdded)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-Ns9df", "unable to unmarshal human otp added")
}
return otpAdded, nil
}
type VerifiedEvent struct {
eventstore.BaseEvent `json:"-"`
State mfa.State `json:"-"`
}
func (e *VerifiedEvent) CheckPrevious() bool {
return true
}
func (e *VerifiedEvent) Data() interface{} {
return nil
}
func NewVerifiedEvent(ctx context.Context) *VerifiedEvent {
return &VerifiedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanMFAOTPVerifiedType,
),
}
}
func VerifiedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &VerifiedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
State: mfa.StateReady,
}, nil
}
type RemovedEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *RemovedEvent) CheckPrevious() bool {
return true
}
func (e *RemovedEvent) Data() interface{} {
return nil
}
func NewRemovedEvent(ctx context.Context) *RemovedEvent {
return &RemovedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanMFAOTPRemovedType,
),
}
}
func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &RemovedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
type CheckSucceededEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *CheckSucceededEvent) CheckPrevious() bool {
return false
}
func (e *CheckSucceededEvent) Data() interface{} {
return nil
}
func NewCheckSucceededEvent(ctx context.Context) *CheckSucceededEvent {
return &CheckSucceededEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanMFAOTPCheckSucceededType,
),
}
}
func CheckSucceededEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &CheckSucceededEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
type CheckFailedEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *CheckFailedEvent) CheckPrevious() bool {
return false
}
func (e *CheckFailedEvent) Data() interface{} {
return nil
}
func NewCheckFailedEvent(ctx context.Context) *CheckFailedEvent {
return &CheckFailedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanMFAOTPCheckFailedType,
),
}
}
func CheckFailedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &CheckFailedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
@@ -0,0 +1,426 @@
package web_auth_n
import (
"context"
"encoding/json"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/eventstore/v2/repository"
"github.com/caos/zitadel/internal/v2/repository/user/human/mfa"
)
const (
u2fEventPrefix = eventstore.EventType("user.human.mfa.u2f.token.")
HumanU2FTokenAddedType = u2fEventPrefix + "added"
HumanU2FTokenVerifiedType = u2fEventPrefix + "verified"
HumanU2FTokenSignCountChangedType = u2fEventPrefix + "signcount.changed"
HumanU2FTokenRemovedType = u2fEventPrefix + "removed"
HumanU2FTokenBeginLoginType = u2fEventPrefix + "begin.login"
HumanU2FTokenCheckSucceededType = u2fEventPrefix + "check.succeeded"
HumanU2FTokenCheckFailedType = u2fEventPrefix + "check.failed"
passwordlessEventPrefix = eventstore.EventType("user.human.mfa.passwordless.token.")
HumanPasswordlessTokenAddedType = passwordlessEventPrefix + "added"
HumanPasswordlessTokenVerifiedType = passwordlessEventPrefix + "verified"
HumanPasswordlessTokenSignCountChangedType = passwordlessEventPrefix + "signcount.changed"
HumanPasswordlessTokenRemovedType = passwordlessEventPrefix + "removed"
HumanPasswordlessTokenBeginLoginType = passwordlessEventPrefix + "begin.login"
HumanPasswordlessTokenCheckSucceededType = passwordlessEventPrefix + "check.succeeded"
HumanPasswordlessTokenCheckFailedType = passwordlessEventPrefix + "check.failed"
)
type AddedEvent struct {
eventstore.BaseEvent `json:"-"`
WebAuthNTokenID string `json:"webAuthNTokenId"`
Challenge string `json:"challenge"`
State mfa.State `json:"-"`
}
func (e *AddedEvent) CheckPrevious() bool {
return true
}
func (e *AddedEvent) Data() interface{} {
return e
}
func NewU2FAddedEvent(
ctx context.Context,
webAuthNTokenID,
challenge string,
) *AddedEvent {
return &AddedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanU2FTokenAddedType,
),
WebAuthNTokenID: webAuthNTokenID,
Challenge: challenge,
}
}
func NewPasswordlessAddedEvent(
ctx context.Context,
webAuthNTokenID,
challenge string,
) *AddedEvent {
return &AddedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordlessTokenAddedType,
),
WebAuthNTokenID: webAuthNTokenID,
Challenge: challenge,
}
}
func AddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
webAuthNAdded := &AddedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
State: mfa.StateNotReady,
}
err := json.Unmarshal(event.Data, webAuthNAdded)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-tB8sf", "unable to unmarshal human webAuthN added")
}
return webAuthNAdded, nil
}
type VerifiedEvent struct {
eventstore.BaseEvent `json:"-"`
WebAuthNTokenID string `json:"webAuthNTokenId"`
KeyID []byte `json:"keyId"`
PublicKey []byte `json:"publicKey"`
AttestationType string `json:"attestationType"`
AAGUID []byte `json:"aaguid"`
SignCount uint32 `json:"signCount"`
WebAuthNTokenName string `json:"webAuthNTokenName"`
State mfa.State `json:"-"`
}
func (e *VerifiedEvent) CheckPrevious() bool {
return true
}
func (e *VerifiedEvent) Data() interface{} {
return e
}
func NewU2FVerifiedEvent(
ctx context.Context,
webAuthNTokenID,
webAuthNTokenName,
attestationType string,
keyID,
publicKey,
aaguid []byte,
signCount uint32,
) *VerifiedEvent {
return &VerifiedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanU2FTokenVerifiedType,
),
WebAuthNTokenID: webAuthNTokenID,
KeyID: keyID,
PublicKey: publicKey,
AttestationType: attestationType,
AAGUID: aaguid,
SignCount: signCount,
WebAuthNTokenName: webAuthNTokenName,
}
}
func NewPasswordlessVerifiedEvent(
ctx context.Context,
webAuthNTokenID,
webAuthNTokenName,
attestationType string,
keyID,
publicKey,
aaguid []byte,
signCount uint32,
) *VerifiedEvent {
return &VerifiedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordlessTokenVerifiedType,
),
WebAuthNTokenID: webAuthNTokenID,
KeyID: keyID,
PublicKey: publicKey,
AttestationType: attestationType,
AAGUID: aaguid,
SignCount: signCount,
WebAuthNTokenName: webAuthNTokenName,
}
}
func VerifiedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
webauthNVerified := &VerifiedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
State: mfa.StateReady,
}
err := json.Unmarshal(event.Data, webauthNVerified)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-B0zDs", "unable to unmarshal human webAuthN verified")
}
return webauthNVerified, nil
}
type SignCountChangedEvent struct {
eventstore.BaseEvent `json:"-"`
WebAuthNTokenID string `json:"webAuthNTokenId"`
SignCount uint32 `json:"signCount"`
State mfa.State `json:"-"`
}
func (e *SignCountChangedEvent) CheckPrevious() bool {
return true
}
func (e *SignCountChangedEvent) Data() interface{} {
return e
}
func NewU2FSignCountChangedEvent(
ctx context.Context,
webAuthNTokenID string,
signCount uint32,
) *SignCountChangedEvent {
return &SignCountChangedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanU2FTokenSignCountChangedType,
),
WebAuthNTokenID: webAuthNTokenID,
SignCount: signCount,
}
}
func NewPasswordlessSignCountChangedEvent(
ctx context.Context,
webAuthNTokenID string,
signCount uint32,
) *SignCountChangedEvent {
return &SignCountChangedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordlessTokenSignCountChangedType,
),
WebAuthNTokenID: webAuthNTokenID,
SignCount: signCount,
}
}
func SignCountChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
webauthNVerified := &SignCountChangedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, webauthNVerified)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-5Gm0s", "unable to unmarshal human webAuthN sign count")
}
return webauthNVerified, nil
}
type RemovedEvent struct {
eventstore.BaseEvent `json:"-"`
WebAuthNTokenID string `json:"webAuthNTokenId"`
State mfa.State `json:"-"`
}
func (e *RemovedEvent) CheckPrevious() bool {
return true
}
func (e *RemovedEvent) Data() interface{} {
return e
}
func NewU2FRemovedEvent(
ctx context.Context,
webAuthNTokenID string,
) *RemovedEvent {
return &RemovedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanU2FTokenRemovedType,
),
WebAuthNTokenID: webAuthNTokenID,
}
}
func NewPasswordlessRemovedEvent(
ctx context.Context,
webAuthNTokenID string,
) *RemovedEvent {
return &RemovedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordlessTokenRemovedType,
),
WebAuthNTokenID: webAuthNTokenID,
}
}
func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
webauthNVerified := &RemovedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, webauthNVerified)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-gM9sd", "unable to unmarshal human webAuthN token removed")
}
return webauthNVerified, nil
}
type BeginLoginEvent struct {
eventstore.BaseEvent `json:"-"`
WebAuthNTokenID string `json:"webAuthNTokenId"`
Challenge string `json:"challenge"`
//TODO: Handle Auth Req??
//*AuthRequest
}
func (e *BeginLoginEvent) CheckPrevious() bool {
return true
}
func (e *BeginLoginEvent) Data() interface{} {
return e
}
func NewU2FBeginLoginEvent(
ctx context.Context,
webAuthNTokenID,
challenge string,
) *BeginLoginEvent {
return &BeginLoginEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanU2FTokenRemovedType,
),
WebAuthNTokenID: webAuthNTokenID,
Challenge: challenge,
}
}
func NewPasswordlessBeginLoginEvent(
ctx context.Context,
webAuthNTokenID,
challenge string,
) *BeginLoginEvent {
return &BeginLoginEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordlessTokenRemovedType,
),
WebAuthNTokenID: webAuthNTokenID,
Challenge: challenge,
}
}
func BeginLoginEventMapper(event *repository.Event) (eventstore.EventReader, error) {
webAuthNAdded := &BeginLoginEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, webAuthNAdded)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-rMb8x", "unable to unmarshal human webAuthN begin login")
}
return webAuthNAdded, nil
}
type CheckSucceededEvent struct {
eventstore.BaseEvent `json:"-"`
//TODO: Handle Auth Req??
//*AuthRequest
}
func (e *CheckSucceededEvent) CheckPrevious() bool {
return true
}
func (e *CheckSucceededEvent) Data() interface{} {
return e
}
func NewU2FCheckSucceededEvent(ctx context.Context) *CheckSucceededEvent {
return &CheckSucceededEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanU2FTokenCheckSucceededType,
),
}
}
func NewPasswordlessCheckSucceededEvent(ctx context.Context) *CheckSucceededEvent {
return &CheckSucceededEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordlessTokenCheckSucceededType,
),
}
}
func CheckSucceededEventMapper(event *repository.Event) (eventstore.EventReader, error) {
webAuthNAdded := &CheckSucceededEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, webAuthNAdded)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-2M0fg", "unable to unmarshal human webAuthN check succeeded")
}
return webAuthNAdded, nil
}
type CheckFailedEvent struct {
eventstore.BaseEvent `json:"-"`
//TODO: Handle Auth Req??
//*AuthRequest
}
func (e *CheckFailedEvent) CheckPrevious() bool {
return true
}
func (e *CheckFailedEvent) Data() interface{} {
return e
}
func NewU2FCheckFailedEvent(ctx context.Context) *CheckFailedEvent {
return &CheckFailedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanU2FTokenCheckFailedType,
),
}
}
func NewPasswordlessCheckFailedEvent(ctx context.Context) *CheckFailedEvent {
return &CheckFailedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordlessTokenCheckFailedType,
),
}
}
func CheckFailedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
webAuthNAdded := &CheckFailedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, webAuthNAdded)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-O0dse", "unable to unmarshal human webAuthN check failed")
}
return webAuthNAdded, nil
}
@@ -0,0 +1,8 @@
package human
type NotificationType int32
const (
NotificationTypeEmail NotificationType = iota
NotificationTypeSms
)
@@ -0,0 +1,189 @@
package password
import (
"context"
"encoding/json"
"github.com/caos/zitadel/internal/crypto"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/eventstore/v2/repository"
"github.com/caos/zitadel/internal/v2/repository/user/human"
"time"
)
const (
passwordEventPrefix = eventstore.EventType("user.human.password.")
HumanPasswordChangedType = passwordEventPrefix + "changed"
HumanPasswordCodeAddedType = passwordEventPrefix + "code.added"
HumanPasswordCodeSentType = passwordEventPrefix + "code.sent"
HumanPasswordCheckSucceededType = passwordEventPrefix + "check.succeeded"
HumanPasswordCheckFailedType = passwordEventPrefix + "check.failed"
)
type ChangedEvent struct {
eventstore.BaseEvent `json:"-"`
Secret *crypto.CryptoValue `json:"secret,omitempty"`
ChangeRequired bool `json:"changeRequired,omitempty"`
}
func (e *ChangedEvent) CheckPrevious() bool {
return false
}
func (e *ChangedEvent) Data() interface{} {
return e
}
func NewChangedEvent(
ctx context.Context,
secret *crypto.CryptoValue,
changeRequired bool,
) *ChangedEvent {
return &ChangedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordChangedType,
),
Secret: secret,
ChangeRequired: changeRequired,
}
}
func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
humanAdded := &ChangedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, humanAdded)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-4M0sd", "unable to unmarshal human password changed")
}
return humanAdded, nil
}
type CodeAddedEvent struct {
eventstore.BaseEvent `json:"-"`
Code *crypto.CryptoValue `json:"code,omitempty"`
Expiry time.Duration `json:"expiry,omitempty"`
NotificationType human.NotificationType `json:"notificationType,omitempty"`
}
func (e *CodeAddedEvent) CheckPrevious() bool {
return false
}
func (e *CodeAddedEvent) Data() interface{} {
return e
}
func NewPasswordCodeAddedEvent(
ctx context.Context,
code *crypto.CryptoValue,
expiry time.Duration,
notificationType human.NotificationType,
) *CodeAddedEvent {
return &CodeAddedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordCodeAddedType,
),
Code: code,
Expiry: expiry,
NotificationType: notificationType,
}
}
func CodeAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
humanAdded := &CodeAddedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, humanAdded)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-Ms90d", "unable to unmarshal human password code added")
}
return humanAdded, nil
}
type CodeSentEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *CodeSentEvent) CheckPrevious() bool {
return false
}
func (e *CodeSentEvent) Data() interface{} {
return nil
}
func NewCodeSentEvent(ctx context.Context) *CodeSentEvent {
return &CodeSentEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordCodeSentType,
),
}
}
func CodeSentEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &CodeSentEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
type CheckSucceededEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *CheckSucceededEvent) CheckPrevious() bool {
return false
}
func (e *CheckSucceededEvent) Data() interface{} {
return nil
}
func NewCheckSucceededEvent(ctx context.Context) *CheckSucceededEvent {
return &CheckSucceededEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordCheckSucceededType,
),
}
}
func CheckSucceededEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &CheckSucceededEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
type CheckFailedEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *CheckFailedEvent) CheckPrevious() bool {
return false
}
func (e *CheckFailedEvent) Data() interface{} {
return nil
}
func NewCheckFailedEvent(ctx context.Context) *CheckFailedEvent {
return &CheckFailedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPasswordCheckFailedType,
),
}
}
func CheckFailedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &CheckFailedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
@@ -0,0 +1,210 @@
package phone
import (
"context"
"encoding/json"
"github.com/caos/zitadel/internal/crypto"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/eventstore/v2/repository"
"time"
)
const (
phoneEventPrefix = eventstore.EventType("user.human.phone.")
HumanPhoneChangedType = phoneEventPrefix + "changed"
HumanPhoneRemovedType = phoneEventPrefix + "removed"
HumanPhoneVerifiedType = phoneEventPrefix + "verified"
HumanPhoneVerificationFailedType = phoneEventPrefix + "verification.failed"
HumanPhoneCodeAddedType = phoneEventPrefix + "code.added"
HumanPhoneCodeSentType = phoneEventPrefix + "code.sent"
)
type ChangedEvent struct {
eventstore.BaseEvent `json:"-"`
PhoneNumber string `json:"phone,omitempty"`
}
func (e *ChangedEvent) CheckPrevious() bool {
return true
}
func (e *ChangedEvent) Data() interface{} {
return e
}
func NewChangedEvent(ctx context.Context, phone string) *ChangedEvent {
return &ChangedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPhoneChangedType,
),
PhoneNumber: phone,
}
}
func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
phoneChangedEvent := &ChangedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, phoneChangedEvent)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-5M0pd", "unable to unmarshal human phone changed")
}
return phoneChangedEvent, nil
}
type RemovedEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *RemovedEvent) CheckPrevious() bool {
return true
}
func (e *RemovedEvent) Data() interface{} {
return nil
}
func NewRemovedEvent(ctx context.Context) *RemovedEvent {
return &RemovedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPhoneRemovedType,
),
}
}
func RemovedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &ChangedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
type VerifiedEvent struct {
eventstore.BaseEvent `json:"-"`
IsPhoneVerified bool `json:"-"`
}
func (e *VerifiedEvent) CheckPrevious() bool {
return true
}
func (e *VerifiedEvent) Data() interface{} {
return nil
}
func NewVerifiedEvent(ctx context.Context) *VerifiedEvent {
return &VerifiedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPhoneVerifiedType,
),
}
}
func VerifiedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &VerifiedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
IsPhoneVerified: true,
}, nil
}
type VerificationFailedEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *VerificationFailedEvent) CheckPrevious() bool {
return true
}
func (e *VerificationFailedEvent) Data() interface{} {
return nil
}
func NewVerificationFailedEvent(ctx context.Context) *VerificationFailedEvent {
return &VerificationFailedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPhoneVerificationFailedType,
),
}
}
func VerificationFailedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &VerificationFailedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
type CodeAddedEvent struct {
eventstore.BaseEvent `json:"-"`
Code *crypto.CryptoValue `json:"code,omitempty"`
Expiry time.Duration `json:"expiry,omitempty"`
}
func (e *CodeAddedEvent) CheckPrevious() bool {
return true
}
func (e *CodeAddedEvent) Data() interface{} {
return e
}
func NewCodeAddedEvent(
ctx context.Context,
code *crypto.CryptoValue,
expiry time.Duration,
) *CodeAddedEvent {
return &CodeAddedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPhoneCodeAddedType,
),
Code: code,
Expiry: expiry,
}
}
func CodeAddedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
codeAdded := &CodeAddedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, codeAdded)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-6Ms9d", "unable to unmarshal human phone code added")
}
return codeAdded, nil
}
type CodeSentEvent struct {
eventstore.BaseEvent `json:"-"`
}
func (e *CodeSentEvent) CheckPrevious() bool {
return false
}
func (e *CodeSentEvent) Data() interface{} {
return e
}
func NewCodeSentEvent(ctx context.Context) *CodeSentEvent {
return &CodeSentEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanPhoneCodeSentType,
),
}
}
func CodeSentEventMapper(event *repository.Event) (eventstore.EventReader, error) {
return &CodeSentEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}, nil
}
@@ -0,0 +1,84 @@
package profile
import (
"context"
"encoding/json"
"github.com/caos/zitadel/internal/errors"
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/eventstore/v2/repository"
"github.com/caos/zitadel/internal/v2/repository/user/human"
"golang.org/x/text/language"
)
const (
profileEventPrefix = eventstore.EventType("user.human.profile.")
HumanProfileChangedType = profileEventPrefix + "changed"
)
type ChangedEvent struct {
eventstore.BaseEvent `json:"-"`
FirstName string `json:"firstName,omitempty"`
LastName string `json:"lastName,omitempty"`
NickName string `json:"nickName,omitempty"`
DisplayName string `json:"displayName,omitempty"`
PreferredLanguage language.Tag `json:"preferredLanguage,omitempty"`
Gender human.Gender `json:"gender,omitempty"`
}
func (e *ChangedEvent) CheckPrevious() bool {
return true
}
func (e *ChangedEvent) Data() interface{} {
return e
}
func NewChangedEvent(
ctx context.Context,
current *WriteModel,
firstName,
lastName,
nickName,
displayName string,
preferredLanguage language.Tag,
gender human.Gender,
) *ChangedEvent {
e := &ChangedEvent{
BaseEvent: *eventstore.NewBaseEventForPush(
ctx,
HumanProfileChangedType,
),
}
if current.FirstName != firstName {
e.FirstName = firstName
}
if current.LastName != lastName {
e.LastName = lastName
}
if current.NickName != nickName {
e.NickName = nickName
}
if current.DisplayName != displayName {
e.DisplayName = displayName
}
if current.PreferredLanguage != preferredLanguage {
e.PreferredLanguage = preferredLanguage
}
if current.Gender != gender {
e.Gender = gender
}
return e
}
func ChangedEventMapper(event *repository.Event) (eventstore.EventReader, error) {
profileChanged := &ChangedEvent{
BaseEvent: *eventstore.BaseEventFromRepo(event),
}
err := json.Unmarshal(event.Data, profileChanged)
if err != nil {
return nil, errors.ThrowInternal(err, "USER-5M0pd", "unable to unmarshal human profile changed")
}
return profileChanged, nil
}
@@ -0,0 +1,18 @@
package profile
import (
"github.com/caos/zitadel/internal/eventstore/v2"
"github.com/caos/zitadel/internal/v2/repository/user/human"
"golang.org/x/text/language"
)
type WriteModel struct {
eventstore.WriteModel
FirstName string
LastName string
NickName string
DisplayName string
PreferredLanguage language.Tag
Gender human.Gender
}