zitadel/internal/command/user_human_refresh_token_model.go

package command

import (
	"time"

	"github.com/zitadel/zitadel/internal/domain"
	"github.com/zitadel/zitadel/internal/eventstore"
	"github.com/zitadel/zitadel/internal/repository/user"
)

type HumanRefreshTokenWriteModel struct {
	eventstore.WriteModel

	TokenID      string
	RefreshToken string

	UserState             domain.UserState
	AuthTime              time.Time
	IdleExpiration        time.Time
	Expiration            time.Time
	UserAgentID           string
	AuthMethodsReferences []string
	Actor                 *domain.TokenActor
}

func NewHumanRefreshTokenWriteModel(userID, resourceOwner, tokenID string) *HumanRefreshTokenWriteModel {
	return &HumanRefreshTokenWriteModel{
		WriteModel: eventstore.WriteModel{
			AggregateID:   userID,
			ResourceOwner: resourceOwner,
		},
		TokenID: tokenID,
	}
}

func (wm *HumanRefreshTokenWriteModel) AppendEvents(events ...eventstore.Event) {
	for _, event := range events {
		switch e := event.(type) {
		case *user.HumanRefreshTokenAddedEvent:
			if wm.TokenID != e.TokenID {
				continue
			}
			wm.WriteModel.AppendEvents(e)
		case *user.HumanRefreshTokenRenewedEvent:
			if wm.TokenID != e.TokenID {
				continue
			}
			wm.WriteModel.AppendEvents(e)
		case *user.HumanRefreshTokenRemovedEvent:
			if wm.TokenID != e.TokenID {
				continue
			}
			wm.WriteModel.AppendEvents(e)
		default:
			wm.WriteModel.AppendEvents(e)
		}
	}
}

func (wm *HumanRefreshTokenWriteModel) Reduce() error {
	for _, event := range wm.Events {
		switch e := event.(type) {
		case *user.HumanRefreshTokenAddedEvent:
			wm.TokenID = e.TokenID
			wm.RefreshToken = e.TokenID
			wm.IdleExpiration = e.CreationDate().Add(e.IdleExpiration)
			wm.Expiration = e.CreationDate().Add(e.Expiration)
			wm.UserState = domain.UserStateActive
			wm.AuthTime = e.AuthTime
			wm.UserAgentID = e.UserAgentID
			wm.AuthMethodsReferences = e.AuthMethodsReferences
			wm.Actor = e.Actor
		case *user.HumanRefreshTokenRenewedEvent:
			if wm.UserState == domain.UserStateActive {
				wm.RefreshToken = e.RefreshToken
			}
			wm.RefreshToken = e.RefreshToken
			wm.IdleExpiration = e.CreationDate().Add(e.IdleExpiration)
		case *user.HumanSignedOutEvent:
			if wm.UserAgentID == e.UserAgentID {
				wm.UserState = domain.UserStateDeleted
			}
		case *user.HumanRefreshTokenRemovedEvent,
			*user.UserLockedEvent,
			*user.UserDeactivatedEvent,
			*user.UserRemovedEvent:

			wm.TokenID = ""
			wm.RefreshToken = ""
			wm.AuthTime = time.Time{}
			wm.IdleExpiration = time.Time{}
			wm.Expiration = time.Time{}
			wm.UserAgentID = ""
			wm.AuthMethodsReferences = nil
			wm.Actor = nil
			wm.UserState = domain.UserStateDeleted
		case *user.HumanAddedEvent, *user.HumanRegisteredEvent, *user.MachineAddedEvent:
			wm.TokenID = ""
			wm.RefreshToken = ""
			wm.AuthTime = time.Time{}
			wm.IdleExpiration = time.Time{}
			wm.Expiration = time.Time{}
			wm.UserAgentID = ""
			wm.AuthMethodsReferences = nil
			wm.Actor = nil
		}
	}
	return wm.WriteModel.Reduce()
}

func (wm *HumanRefreshTokenWriteModel) Query() *eventstore.SearchQueryBuilder {
	query := eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
		AddQuery().
		AggregateTypes(user.AggregateType).
		AggregateIDs(wm.AggregateID).
		EventTypes(
			user.HumanAddedType,
			user.HumanRegisteredType,
			user.MachineAddedEventType,
			user.HumanRefreshTokenAddedType,
			user.HumanRefreshTokenRenewedType,
			user.HumanRefreshTokenRemovedType,
			user.HumanSignedOutType,
			user.UserLockedType,
			user.UserDeactivatedType,
			user.UserRemovedType).
		Builder()

	if wm.ResourceOwner != "" {
		query.ResourceOwner(wm.ResourceOwner)
	}
	return query
}