tyapi-server/internal/domains/user/events/user_events.go

package events

import (
	"encoding/json"
	"time"

	"tyapi-server/internal/domains/user/entities"

	"github.com/google/uuid"
)

// UserEventType 用户事件类型
type UserEventType string

const (
	UserCreatedEvent         UserEventType = "user.created"
	UserUpdatedEvent         UserEventType = "user.updated"
	UserDeletedEvent         UserEventType = "user.deleted"
	UserRestoredEvent        UserEventType = "user.restored"
	UserLoggedInEvent        UserEventType = "user.logged_in"
	UserLoggedOutEvent       UserEventType = "user.logged_out"
	UserPasswordChangedEvent UserEventType = "user.password_changed"
	UserStatusChangedEvent   UserEventType = "user.status_changed"
	UserProfileUpdatedEvent  UserEventType = "user.profile_updated"
)

// BaseUserEvent 用户事件基础结构
type BaseUserEvent struct {
	ID            string                 `json:"id"`
	Type          string                 `json:"type"`
	Version       string                 `json:"version"`
	Timestamp     time.Time              `json:"timestamp"`
	Source        string                 `json:"source"`
	AggregateID   string                 `json:"aggregate_id"`
	AggregateType string                 `json:"aggregate_type"`
	Metadata      map[string]interface{} `json:"metadata"`
	Payload       interface{}            `json:"payload"`

	// DDD特有字段
	DomainVersion string `json:"domain_version"`
	CausationID   string `json:"causation_id"`
	CorrelationID string `json:"correlation_id"`
}

// 实现 Event 接口
func (e *BaseUserEvent) GetID() string {
	return e.ID
}

func (e *BaseUserEvent) GetType() string {
	return e.Type
}

func (e *BaseUserEvent) GetVersion() string {
	return e.Version
}

func (e *BaseUserEvent) GetTimestamp() time.Time {
	return e.Timestamp
}

func (e *BaseUserEvent) GetPayload() interface{} {
	return e.Payload
}

func (e *BaseUserEvent) GetMetadata() map[string]interface{} {
	return e.Metadata
}

func (e *BaseUserEvent) GetSource() string {
	return e.Source
}

func (e *BaseUserEvent) GetAggregateID() string {
	return e.AggregateID
}

func (e *BaseUserEvent) GetAggregateType() string {
	return e.AggregateType
}

func (e *BaseUserEvent) GetDomainVersion() string {
	return e.DomainVersion
}

func (e *BaseUserEvent) GetCausationID() string {
	return e.CausationID
}

func (e *BaseUserEvent) GetCorrelationID() string {
	return e.CorrelationID
}

func (e *BaseUserEvent) Marshal() ([]byte, error) {
	return json.Marshal(e)
}

func (e *BaseUserEvent) Unmarshal(data []byte) error {
	return json.Unmarshal(data, e)
}

// UserCreated 用户创建事件
type UserCreated struct {
	*BaseUserEvent
	User *entities.User `json:"user"`
}

func NewUserCreatedEvent(user *entities.User, correlationID string) *UserCreated {
	return &UserCreated{
		BaseUserEvent: &BaseUserEvent{
			ID:            uuid.New().String(),
			Type:          string(UserCreatedEvent),
			Version:       "1.0",
			Timestamp:     time.Now(),
			Source:        "user-service",
			AggregateID:   user.ID,
			AggregateType: "User",
			DomainVersion: "1.0",
			CorrelationID: correlationID,
			Metadata: map[string]interface{}{
				"user_id":  user.ID,
				"username": user.Username,
				"email":    user.Email,
			},
		},
		User: user,
	}
}

func (e *UserCreated) GetPayload() interface{} {
	return e.User
}

// UserUpdated 用户更新事件
type UserUpdated struct {
	*BaseUserEvent
	UserID    string                 `json:"user_id"`
	Changes   map[string]interface{} `json:"changes"`
	OldValues map[string]interface{} `json:"old_values"`
	NewValues map[string]interface{} `json:"new_values"`
}

func NewUserUpdatedEvent(userID string, changes, oldValues, newValues map[string]interface{}, correlationID string) *UserUpdated {
	return &UserUpdated{
		BaseUserEvent: &BaseUserEvent{
			ID:            uuid.New().String(),
			Type:          string(UserUpdatedEvent),
			Version:       "1.0",
			Timestamp:     time.Now(),
			Source:        "user-service",
			AggregateID:   userID,
			AggregateType: "User",
			DomainVersion: "1.0",
			CorrelationID: correlationID,
			Metadata: map[string]interface{}{
				"user_id":        userID,
				"changed_fields": len(changes),
			},
		},
		UserID:    userID,
		Changes:   changes,
		OldValues: oldValues,
		NewValues: newValues,
	}
}

// UserDeleted 用户删除事件
type UserDeleted struct {
	*BaseUserEvent
	UserID     string `json:"user_id"`
	Username   string `json:"username"`
	Email      string `json:"email"`
	SoftDelete bool   `json:"soft_delete"`
}

func NewUserDeletedEvent(userID, username, email string, softDelete bool, correlationID string) *UserDeleted {
	return &UserDeleted{
		BaseUserEvent: &BaseUserEvent{
			ID:            uuid.New().String(),
			Type:          string(UserDeletedEvent),
			Version:       "1.0",
			Timestamp:     time.Now(),
			Source:        "user-service",
			AggregateID:   userID,
			AggregateType: "User",
			DomainVersion: "1.0",
			CorrelationID: correlationID,
			Metadata: map[string]interface{}{
				"user_id":     userID,
				"username":    username,
				"email":       email,
				"soft_delete": softDelete,
			},
		},
		UserID:     userID,
		Username:   username,
		Email:      email,
		SoftDelete: softDelete,
	}
}

// UserLoggedIn 用户登录事件
type UserLoggedIn struct {
	*BaseUserEvent
	UserID    string `json:"user_id"`
	Username  string `json:"username"`
	IPAddress string `json:"ip_address"`
	UserAgent string `json:"user_agent"`
}

func NewUserLoggedInEvent(userID, username, ipAddress, userAgent, correlationID string) *UserLoggedIn {
	return &UserLoggedIn{
		BaseUserEvent: &BaseUserEvent{
			ID:            uuid.New().String(),
			Type:          string(UserLoggedInEvent),
			Version:       "1.0",
			Timestamp:     time.Now(),
			Source:        "user-service",
			AggregateID:   userID,
			AggregateType: "User",
			DomainVersion: "1.0",
			CorrelationID: correlationID,
			Metadata: map[string]interface{}{
				"user_id":    userID,
				"username":   username,
				"ip_address": ipAddress,
				"user_agent": userAgent,
			},
		},
		UserID:    userID,
		Username:  username,
		IPAddress: ipAddress,
		UserAgent: userAgent,
	}
}

// UserPasswordChanged 用户密码修改事件
type UserPasswordChanged struct {
	*BaseUserEvent
	UserID   string `json:"user_id"`
	Username string `json:"username"`
}

func NewUserPasswordChangedEvent(userID, username, correlationID string) *UserPasswordChanged {
	return &UserPasswordChanged{
		BaseUserEvent: &BaseUserEvent{
			ID:            uuid.New().String(),
			Type:          string(UserPasswordChangedEvent),
			Version:       "1.0",
			Timestamp:     time.Now(),
			Source:        "user-service",
			AggregateID:   userID,
			AggregateType: "User",
			DomainVersion: "1.0",
			CorrelationID: correlationID,
			Metadata: map[string]interface{}{
				"user_id":  userID,
				"username": username,
			},
		},
		UserID:   userID,
		Username: username,
	}
}

// UserStatusChanged 用户状态变更事件
type UserStatusChanged struct {
	*BaseUserEvent
	UserID    string              `json:"user_id"`
	Username  string              `json:"username"`
	OldStatus entities.UserStatus `json:"old_status"`
	NewStatus entities.UserStatus `json:"new_status"`
}

func NewUserStatusChangedEvent(userID, username string, oldStatus, newStatus entities.UserStatus, correlationID string) *UserStatusChanged {
	return &UserStatusChanged{
		BaseUserEvent: &BaseUserEvent{
			ID:            uuid.New().String(),
			Type:          string(UserStatusChangedEvent),
			Version:       "1.0",
			Timestamp:     time.Now(),
			Source:        "user-service",
			AggregateID:   userID,
			AggregateType: "User",
			DomainVersion: "1.0",
			CorrelationID: correlationID,
			Metadata: map[string]interface{}{
				"user_id":    userID,
				"username":   username,
				"old_status": oldStatus,
				"new_status": newStatus,
			},
		},
		UserID:    userID,
		Username:  username,
		OldStatus: oldStatus,
		NewStatus: newStatus,
	}
}