Events Module (recerdo-events)¶

// Event エンティティ
type Event struct {
    ID            string    // ULID
    OrgID         string    // UUID
    Title         string
    Description   *string
    StartDate     time.Time
    EndDate       time.Time
    Status        string    // DRAFT, ACTIVE, ARCHIVED
    EventCode     *string   // unique per org, e.g. "SUMMER-PARTY-2026"
    CoverMediaID  *string   // reference to media service
    CreatedBy     string    // user_id
    CreatedAt     time.Time
    UpdatedAt     time.Time
}

func (e *Event) Validate() error {
    if e.Title == "" {
        return ErrEventTitleRequired
    }
    if e.StartDate.After(e.EndDate) {
        return ErrInvalidDateRange
    }
    if e.Status != "DRAFT" && e.Status != "ACTIVE" && e.Status != "ARCHIVED" {
        return ErrInvalidEventStatus
    }
    return nil
}

func (e *Event) IsArchived() bool {
    return e.Status == "ARCHIVED"
}

func (e *Event) CanBeUpdated() bool {
    return e.Status != "ARCHIVED"
}

func (e *Event) CanInviteMembers() bool {
    return e.Status == "ACTIVE"
}

func (e *Event) TransitionToDraft() error {
    if e.Status != "DRAFT" {
        return ErrCannotTransitionToDraft
    }
    return nil
}

func (e *Event) TransitionToActive() error {
    if e.Status != "DRAFT" {
        return ErrCannotTransitionToActive
    }
    if e.Title == "" {
        return ErrEventTitleRequired
    }
    e.Status = "ACTIVE"
    return nil
}

func (e *Event) TransitionToArchived() error {
    if e.Status == "ARCHIVED" {
        return ErrAlreadyArchived
    }
    e.Status = "ARCHIVED"
    return nil
}

// EventInvitation エンティティ
type EventInvitation struct {
    ID            string     // ULID
    EventID       string
    OrgID         string
    Email         string
    InvitedBy     string     // user_id
    Role          string     // MEMBER, GUEST
    Status        string     // PENDING, ACCEPTED, DECLINED, EXPIRED
    InvitedAt     time.Time
    RespondedAt   *time.Time
    AcceptedUserID *string   // user_id of who accepted
    ExpiresAt     time.Time
}

func (i *EventInvitation) IsExpired(now time.Time) bool {
    return now.After(i.ExpiresAt)
}

func (i *EventInvitation) CanRespond(now time.Time) bool {
    return i.Status == "PENDING" && !i.IsExpired(now)
}

func (i *EventInvitation) Accept(userID string, now time.Time) error {
    if !i.CanRespond(now) {
        return ErrCannotRespondToInvitation
    }
    i.Status = "ACCEPTED"
    i.RespondedAt = &now
    i.AcceptedUserID = &userID
    return nil
}

func (i *EventInvitation) Decline(now time.Time) error {
    if !i.CanRespond(now) {
        return ErrCannotRespondToInvitation
    }
    i.Status = "DECLINED"
    i.RespondedAt = &now
    return nil
}

func (i *EventInvitation) ExpireIfNeeded(now time.Time) {
    if i.IsExpired(now) && i.Status == "PENDING" {
        i.Status = "EXPIRED"
    }
}

// EventCode 値オブジェクト
type EventCode string

func NewEventCode(code string) (EventCode, error) {
    if len(code) == 0 || len(code) > 30 {
        return "", ErrInvalidEventCodeLength
    }
    // Must be alphanumeric + hyphens, uppercase only
    if !regexp.MustCompile(`^[A-Z0-9\-]+$`).MatchString(code) {
        return "", ErrInvalidEventCodeFormat
    }
    return EventCode(code), nil
}

func (ec EventCode) String() string {
    return string(ec)
}

// EventParticipant エンティティ
type EventParticipant struct {
    ID         string    // ULID
    EventID    string
    OrgID      string
    UserID     string    // user_id
    Email      string
    Role       string    // OWNER, ADMIN, MEMBER, GUEST
    JoinedVia  string    // INVITATION, EVENT_CODE, DIRECT
    JoinedAt   time.Time
    LastActivityAt time.Time
}

func (ep *EventParticipant) CanManageEvent() bool {
    return ep.Role == "OWNER" || ep.Role == "ADMIN"
}

func (ep *EventParticipant) CanInvite() bool {
    return ep.Role == "OWNER" || ep.Role == "ADMIN"
}

func (ep *EventParticipant) HasEditAccess() bool {
    return ep.Role == "OWNER" || ep.Role == "ADMIN" || ep.Role == "MEMBER"
}

// EventRole 値オブジェクト
type EventRole string

const (
    RoleOwner   EventRole = "OWNER"
    RoleAdmin   EventRole = "ADMIN"
    RoleMember  EventRole = "MEMBER"
    RoleGuest   EventRole = "GUEST"
)

func (r EventRole) CanInvite() bool {
    return r == RoleOwner || r == RoleAdmin
}

func (r EventRole) CanEdit() bool {
    return r == RoleOwner || r == RoleAdmin || r == RoleMember
}

// Repository Ports
type EventRepository interface {
    Create(ctx context.Context, event *Event) error
    GetByID(ctx context.Context, eventID string) (*Event, error)
    UpdateByID(ctx context.Context, eventID string, event *Event) error
    ListByOrgID(ctx context.Context, orgID string, status *string, limit, offset int) ([]*Event, int64, error)
    DeleteByID(ctx context.Context, eventID string) error // Actually archive
}

type EventInvitationRepository interface {
    Create(ctx context.Context, invitation *EventInvitation) error
    GetByID(ctx context.Context, invitationID string) (*EventInvitation, error)
    GetByEmailAndEvent(ctx context.Context, email, eventID string) (*EventInvitation, error)
    UpdateByID(ctx context.Context, invitationID string, invitation *EventInvitation) error
    ListByEventID(ctx context.Context, eventID string, status *string, limit, offset int) ([]*EventInvitation, int64, error)
    ListExpiredPending(ctx context.Context, beforeTime time.Time, limit int) ([]*EventInvitation, error)
    UpdateStatusByID(ctx context.Context, invitationID string, newStatus string) error
}

type EventCodeRepository interface {
    Create(ctx context.Context, code, eventID, orgID string) error
    GetByEventID(ctx context.Context, eventID string) (*EventCode, error)
    GetByCode(ctx context.Context, code, orgID string) (*EventCode, error)
    UpdateByEventID(ctx context.Context, eventID string, newCode string) error
    ExistsByCode(ctx context.Context, code, orgID string) (bool, error)
}

type EventParticipantRepository interface {
    Create(ctx context.Context, participant *EventParticipant) error
    GetByID(ctx context.Context, participantID string) (*EventParticipant, error)
    GetByEventAndUser(ctx context.Context, eventID, userID string) (*EventParticipant, error)
    UpdateByID(ctx context.Context, participantID string, participant *EventParticipant) error
    ListByEventID(ctx context.Context, eventID string, limit, offset int) ([]*EventParticipant, int64, error)
    ListByUserID(ctx context.Context, userID string, limit, offset int) ([]*EventParticipant, int64, error)
    DeleteByID(ctx context.Context, participantID string) error
}

// Service Ports
type PermissionPort interface {
    CanCreateEvent(ctx context.Context, orgID, userID string) (bool, error)
    CanEditEvent(ctx context.Context, orgID, eventID, userID string) (bool, error)
    CanInviteToEvent(ctx context.Context, orgID, eventID, userID string) (bool, error)
    CanArchiveEvent(ctx context.Context, orgID, eventID, userID string) (bool, error)
    IsOrgMember(ctx context.Context, orgID, userID string) (bool, error)
}

type EventCodeGeneratorPort interface {
    Generate(ctx context.Context, orgID, eventTitle string) (string, error)
}

type NotificationPort interface {
    SendInvitationEmail(ctx context.Context, email, eventTitle string, invitationID string) error
    SendParticipationNotification(ctx context.Context, userID string, eventID string) error
}

type AuthServicePort interface {
    GetUserByEmail(ctx context.Context, email string) (*AuthUser, error)
}

type EventPublisherPort interface {
    PublishEventCreated(ctx context.Context, event *Event, createdBy string) error
    PublishEventStatusChanged(ctx context.Context, eventID string, oldStatus, newStatus string, changedBy string) error
    PublishEventArchived(ctx context.Context, event *Event, archivedBy string) error
    PublishEventInvitationSent(ctx context.Context, invitation *EventInvitation) error
    PublishEventInvitationAccepted(ctx context.Context, invitation *EventInvitation) error
    PublishEventInvitationDeclined(ctx context.Context, invitation *EventInvitation) error
    PublishUserJoinedByCode(ctx context.Context, eventID, orgID, userID, email, code string) error
}

fx.Provide(
    // Repositories
    NewMySQLEventRepository,           // → EventRepository
    NewMySQLEventInvitationRepository, // → EventInvitationRepository
    NewMySQLEventCodeRepository,       // → EventCodeRepository
    NewMySQLEventParticipantRepository,// → EventParticipantRepository

    // Service Adapters
    NewPermissionServiceGRPCAdapter,  // → PermissionPort
    NewAuthServiceGRPCAdapter,        // → AuthServicePort
    NewNotificationServiceQueueAdapter, // → NotificationPort (QueuePort)
    NewUUIDSlugCodeGenerator,           // → EventCodeGeneratorPort
    NewQueueEventPublisher,             // → EventPublisherPort (Beta: Redis+BullMQ/asynq、本番: OCI Queue)

    // Use Cases
    NewCreateEventUseCase,
    NewUpdateEventUseCase,
    NewActivateEventUseCase,
    NewArchiveEventUseCase,
    NewGetEventUseCase,
    NewListEventsByOrgUseCase,
    NewInviteMemberByEmailUseCase,
    NewRespondToInvitationUseCase,
    NewJoinEventByCodeUseCase,
    NewListEventInvitationsUseCase,
    NewListEventParticipantsUseCase,
    NewRemoveParticipantUseCase,
    NewGetUserEventsUseCase,
    NewExpireOldInvitationsUseCase,

    // HTTP Handlers
    NewEventHTTPHandler,
    NewInvitationHTTPHandler,
    NewParticipantHTTPHandler,
    NewEventCodeHTTPHandler,
    NewJoinHTTPHandler,
)

// Entity Test
func TestEvent_Validate_InvalidDateRange(t *testing.T) {
    event := &Event{
        Title:     "Summer Party",
        StartDate: time.Date(2026, 7, 16, 0, 0, 0, 0, time.UTC),
        EndDate:   time.Date(2026, 7, 15, 0, 0, 0, 0, time.UTC), // 逆
        Status:    "DRAFT",
    }
    err := event.Validate()
    assert.ErrorIs(t, err, ErrInvalidDateRange)
}

func TestEvent_TransitionToActive_SuccessfullyTransitions(t *testing.T) {
    event := &Event{
        Title:  "Summer Party",
        Status: "DRAFT",
    }
    err := event.TransitionToActive()
    assert.NoError(t, err)
    assert.Equal(t, "ACTIVE", event.Status)
}

func TestEventCode_NewEventCode_InvalidFormat(t *testing.T) {
    _, err := NewEventCode("summer-party-2026") // lowercase
    assert.ErrorIs(t, err, ErrInvalidEventCodeFormat)

    _, err = NewEventCode("SUMMER_PARTY_2026") // underscore
    assert.ErrorIs(t, err, ErrInvalidEventCodeFormat)
}

func TestEventInvitation_Accept_Success(t *testing.T) {
    invitation := &EventInvitation{
        Status:    "PENDING",
        ExpiresAt: time.Now().Add(30 * 24 * time.Hour),
    }
    now := time.Now()
    err := invitation.Accept("user-123", now)
    assert.NoError(t, err)
    assert.Equal(t, "ACCEPTED", invitation.Status)
    assert.Equal(t, "user-123", *invitation.AcceptedUserID)
    assert.NotNil(t, invitation.RespondedAt)
}

func TestEventInvitation_Accept_ExpiredInvitation(t *testing.T) {
    invitation := &EventInvitation{
        Status:    "PENDING",
        ExpiresAt: time.Now().Add(-1 * time.Hour),
    }
    now := time.Now()
    err := invitation.Accept("user-123", now)
    assert.ErrorIs(t, err, ErrCannotRespondToInvitation)
}

// UseCase Test
func TestCreateEventUseCase_Success(t *testing.T) {
    mockEventRepo := new(MockEventRepository)
    mockEventRepo.On("Create", mock.Anything, mock.MatchedBy(func(e *Event) bool {
        return e.Title == "Summer Party" && e.Status == "DRAFT"
    })).Return(nil)

    mockCodeRepo := new(MockEventCodeRepository)
    mockCodeRepo.On("Create", mock.Anything, "SUMMER-PARTY-2026", mock.Anything, "org-123").Return(nil)

    mockParticipantRepo := new(MockEventParticipantRepository)
    mockParticipantRepo.On("Create", mock.Anything, mock.Anything).Return(nil)

    mockPublisher := new(MockEventPublisherPort)
    mockPublisher.On("PublishEventCreated", mock.Anything, mock.Anything, "user-123").Return(nil)

    mockPermission := new(MockPermissionPort)
    mockPermission.On("CanCreateEvent", mock.Anything, "org-123", "user-123").Return(true, nil)

    uc := NewCreateEventUseCase(
        mockEventRepo,
        mockCodeRepo,
        mockParticipantRepo,
        mockPublisher,
        mockPermission,
    )

    input := CreateEventInput{
        OrgID:     "org-123",
        Title:     "Summer Party",
        StartDate: time.Date(2026, 7, 15, 0, 0, 0, 0, time.UTC),
        EndDate:   time.Date(2026, 7, 16, 0, 0, 0, 0, time.UTC),
        CreatedBy: "user-123",
    }

    output, err := uc.Execute(context.Background(), input)
    assert.NoError(t, err)
    assert.Equal(t, "DRAFT", output.Status)
    assert.NotEmpty(t, output.EventID)
    assert.NotEmpty(t, output.EventCode)
}

func TestInviteMemberByEmailUseCase_AlreadyInvited(t *testing.T) {
    mockEventRepo := new(MockEventRepository)
    mockEventRepo.On("GetByID", mock.Anything, "event-123").Return(&Event{Status: "ACTIVE"}, nil)

    mockInvitationRepo := new(MockEventInvitationRepository)
    mockInvitationRepo.On("GetByEmailAndEvent", mock.Anything, "user@example.com", "event-123").
        Return(&EventInvitation{Status: "PENDING"}, nil)

    mockPermission := new(MockPermissionPort)
    mockPermission.On("CanInviteToEvent", mock.Anything, "org-123", "event-123", "admin-user").
        Return(true, nil)

    uc := NewInviteMemberByEmailUseCase(
        mockEventRepo,
        mockInvitationRepo,
        mockPermission,
        nil, // publisher
        nil, // notification
    )

    input := InviteMemberByEmailInput{
        EventID:   "event-123",
        OrgID:     "org-123",
        Email:     "user@example.com",
        InvitedBy: "admin-user",
    }

    _, err := uc.Execute(context.Background(), input)
    assert.ErrorIs(t, err, ErrAlreadyInvited)
}

// Integration Test
func TestEventRepository_Create_InsertAndRetrieve(t *testing.T) {
    if testing.Short() {
        t.Skip("Skipping integration test in short mode")
    }

    container, db := setupMySQLContainer(t)
    defer container.Terminate(context.Background())

    repo := NewMySQLEventRepository(db)

    event := &Event{
        ID:        ulid.Make().String(),
        OrgID:     "org-123",
        Title:     "Summer Party",
        StartDate: time.Date(2026, 7, 15, 0, 0, 0, 0, time.UTC),
        EndDate:   time.Date(2026, 7, 16, 0, 0, 0, 0, time.UTC),
        Status:    "DRAFT",
        CreatedBy: "user-123",
        CreatedAt: time.Now(),
        UpdatedAt: time.Now(),
    }

    err := repo.Create(context.Background(), event)
    assert.NoError(t, err)

    retrieved, err := repo.GetByID(context.Background(), event.ID)
    assert.NoError(t, err)
    assert.Equal(t, event.Title, retrieved.Title)
    assert.Equal(t, event.Status, retrieved.Status)
}

func TestEventInvitationRepository_ListExpiredPending(t *testing.T) {
    if testing.Short() {
        t.Skip("Skipping integration test in short mode")
    }

    container, db := setupMySQLContainer(t)
    defer container.Terminate(context.Background())

    repo := NewMySQLEventInvitationRepository(db)

    now := time.Now()
    expiredInvitation := &EventInvitation{
        ID:        ulid.Make().String(),
        EventID:   "event-123",
        OrgID:     "org-123",
        Email:     "user@example.com",
        InvitedBy: "admin-123",
        Status:    "PENDING",
        ExpiresAt: now.Add(-1 * time.Hour), // expired
        InvitedAt: now.Add(-31 * 24 * time.Hour),
    }

    err := repo.Create(context.Background(), expiredInvitation)
    assert.NoError(t, err)

    results, err := repo.ListExpiredPending(context.Background(), now, 100)
    assert.NoError(t, err)
    assert.Len(t, results, 1)
    assert.Equal(t, expiredInvitation.Email, results[0].Email)
}