pangolin/server/internal/admin/services.go

package admin

import (
	"context"
	"errors"
	"time"

	"github.com/wangjia/pangolin/server/internal/codes"
)

// ErrServiceUnavailable is returned by stub services whose real implementation
// (#5 lifecycle, #14 provisioning) is not yet wired in. The UI greys out the
// corresponding controls when Ready() is false.
var ErrServiceUnavailable = errors.New("admin: service not available yet")

// --------------------------------------------------------------------------
// Code-batch service (#3 codes — implemented)
// --------------------------------------------------------------------------

// CodeBatchParams are the inputs to a batch generation.
type CodeBatchParams struct {
	Plan         string
	DurationDays int
	Count        int
	Channel      string
	Note         string
	CreatedBy    string
}

// GeneratedBatch carries the one-and-only plaintext output of a generation.
type GeneratedBatch struct {
	BatchID      int64
	Plan         string
	DurationDays int
	Channel      string
	Codes        []string // plaintext, streamed to CSV once and never stored
	GeneratedAt  time.Time
}

// CodesService is the subset of the #3 codes service the admin UI consumes.
type CodesService interface {
	CreateBatch(ctx context.Context, p CodeBatchParams) (*GeneratedBatch, error)
	ListBatches(ctx context.Context, limit, offset int) ([]BatchSummary, int, error)
	VoidBatch(ctx context.Context, batchID int64) (int64, error)
}

// CodesAdapter adapts the real codes.Service / codes.Store to CodesService.
type CodesAdapter struct {
	svc   *codes.Service
	store *codes.Store
}

// NewCodesAdapter wires the real codes implementation.
func NewCodesAdapter(svc *codes.Service, store *codes.Store) *CodesAdapter {
	return &CodesAdapter{svc: svc, store: store}
}

// CreateBatch generates a batch and returns the plaintext codes.
func (a *CodesAdapter) CreateBatch(ctx context.Context, p CodeBatchParams) (*GeneratedBatch, error) {
	res, err := a.svc.CreateBatch(ctx, codes.BatchRequest{
		PlanCode:     codes.PlanCode(p.Plan),
		DurationDays: p.DurationDays,
		Count:        p.Count,
		Channel:      codes.BatchChannel(p.Channel),
		Note:         p.Note,
		CreatedBy:    p.CreatedBy,
	})
	if err != nil {
		return nil, err
	}
	return &GeneratedBatch{
		BatchID:      res.BatchID,
		Plan:         string(res.PlanCode),
		DurationDays: res.DurationDays,
		Channel:      string(res.Channel),
		Codes:        res.Codes,
		GeneratedAt:  time.Now().UTC(),
	}, nil
}

// ListBatches returns paginated batch summaries.
func (a *CodesAdapter) ListBatches(ctx context.Context, limit, offset int) ([]BatchSummary, int, error) {
	infos, total, err := a.store.ListBatches(ctx, limit, offset)
	if err != nil {
		return nil, 0, err
	}
	out := make([]BatchSummary, len(infos))
	for i, b := range infos {
		out[i] = BatchSummary{
			ID:        b.ID,
			Channel:   string(b.Channel),
			CreatedBy: b.CreatedBy,
			Note:      b.Note,
			CreatedAt: b.CreatedAt,
			Total:     b.Total,
			Redeemed:  b.Redeemed,
			Void:      b.Void,
			Unused:    b.Unused,
		}
	}
	return out, total, nil
}

// VoidBatch voids all unused codes in a batch.
func (a *CodesAdapter) VoidBatch(ctx context.Context, batchID int64) (int64, error) {
	return a.store.VoidBatch(ctx, batchID)
}

// --------------------------------------------------------------------------
// Node lifecycle service (#5) — not yet implemented
// --------------------------------------------------------------------------

// LifecycleService transitions a node's status (draining / up). Backed by the
// #5 lifecycle module once available.
type LifecycleService interface {
	// TransitionStatus moves nodeID to target ("draining" | "up").
	TransitionStatus(ctx context.Context, nodeID int64, target, actor string) error
	// Ready reports whether the real implementation is wired (UI greys out
	// controls when false).
	Ready() bool
}

// StubLifecycle is the placeholder used until #5 lands.
type StubLifecycle struct{}

// NewStubLifecycle returns a not-ready lifecycle service.
func NewStubLifecycle() *StubLifecycle { return &StubLifecycle{} }

// TransitionStatus always fails until #5 is wired.
func (StubLifecycle) TransitionStatus(context.Context, int64, string, string) error {
	return ErrServiceUnavailable
}

// Ready reports false.
func (StubLifecycle) Ready() bool { return false }

// --------------------------------------------------------------------------
// Node provisioning service (#14) — not yet implemented
// --------------------------------------------------------------------------

// ProvisionService replaces a node by provisioning a fresh one. Backed by the
// #14 ProvisionService once available.
type ProvisionService interface {
	// Replace decommissions nodeID and provisions a replacement.
	Replace(ctx context.Context, nodeID int64, actor string) error
	// Ready reports whether the real implementation is wired.
	Ready() bool
}

// StubProvision is the placeholder used until #14 lands.
type StubProvision struct{}

// NewStubProvision returns a not-ready provision service.
func NewStubProvision() *StubProvision { return &StubProvision{} }

// Replace always fails until #14 is wired.
func (StubProvision) Replace(context.Context, int64, string) error { return ErrServiceUnavailable }

// Ready reports false.
func (StubProvision) Ready() bool { return false }

// Services bundles the three downstream services the admin UI depends on.
type Services struct {
	Codes     CodesService
	Lifecycle LifecycleService
	Provision ProvisionService
}