221 lines
7.1 KiB
Go
221 lines
7.1 KiB
Go
// Package backofficeadmin is the commerce control-plane admin surface for the
|
|
// cart-actor system: read-only cart/checkout history (replayed from event logs),
|
|
// inventory CRUD (Redis), promotions/vouchers JSON, and a WebSocket feed of cart
|
|
// mutations consumed from RabbitMQ.
|
|
//
|
|
// It is extracted from the former cmd/backoffice main package so the same admin
|
|
// surface can run standalone (cmd/backoffice) or be mounted into the all-in-one
|
|
// backoffice host. Because it imports the cart/checkout domain (and the private
|
|
// git.k6n.net module), the host only compiles it into its implementation-specific
|
|
// (commerce) build variant.
|
|
package backofficeadmin
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"time"
|
|
|
|
actor "git.k6n.net/mats/go-cart-actor/pkg/actor"
|
|
"git.k6n.net/mats/go-cart-actor/pkg/cart"
|
|
"git.k6n.net/mats/go-cart-actor/pkg/checkout"
|
|
"git.k6n.net/mats/go-cart-actor/pkg/profile"
|
|
"git.k6n.net/mats/go-redis-inventory/pkg/inventory"
|
|
"git.k6n.net/mats/slask-finder/pkg/messaging"
|
|
amqp "github.com/rabbitmq/amqp091-go"
|
|
"github.com/redis/go-redis/v9"
|
|
)
|
|
|
|
// CartFileInfo is the metadata returned by the cart listing endpoint.
|
|
type CartFileInfo struct {
|
|
ID string `json:"id"`
|
|
CartId cart.CartId `json:"cartId"`
|
|
Size int64 `json:"size"`
|
|
Modified time.Time `json:"modified"`
|
|
}
|
|
|
|
// CheckoutFileInfo is the metadata returned by the checkout listing endpoint.
|
|
type CheckoutFileInfo struct {
|
|
ID string `json:"id"`
|
|
CheckoutId checkout.CheckoutId `json:"checkoutId"`
|
|
Size int64 `json:"size"`
|
|
Modified time.Time `json:"modified"`
|
|
}
|
|
|
|
// Config parameterizes the commerce admin App.
|
|
type Config struct {
|
|
// DataDir holds the cart event logs (default "data").
|
|
DataDir string
|
|
// CheckoutDataDir holds the checkout event logs (default "checkout-data").
|
|
CheckoutDataDir string
|
|
// ProfileDataDir holds the profile event logs (optional, default "" — customer endpoints disabled).
|
|
ProfileDataDir string
|
|
// RedisAddress / RedisPassword reach the inventory store.
|
|
RedisAddress string
|
|
RedisPassword string
|
|
}
|
|
|
|
// App is the commerce admin control plane. Construct with New, register its
|
|
// HTTP surface with RegisterRoutes, run background work with Start.
|
|
type App struct {
|
|
fs *FileServer
|
|
hub *Hub
|
|
rdb *redis.Client
|
|
inv *inventory.RedisInventoryService
|
|
cs *CustomerServer
|
|
}
|
|
|
|
// New constructs the commerce admin: it opens the Redis inventory service, the
|
|
// cart/checkout disk event-log stores, the file server, and the WebSocket hub.
|
|
// It does not register routes (RegisterRoutes), start background work (Start),
|
|
// or open a listener.
|
|
func New(cfg Config) (*App, error) {
|
|
if cfg.DataDir == "" {
|
|
cfg.DataDir = "data"
|
|
}
|
|
if cfg.CheckoutDataDir == "" {
|
|
cfg.CheckoutDataDir = "checkout-data"
|
|
}
|
|
|
|
rdb := redis.NewClient(&redis.Options{
|
|
Addr: cfg.RedisAddress,
|
|
Password: cfg.RedisPassword,
|
|
DB: 0,
|
|
})
|
|
inventoryService, err := inventory.NewRedisInventoryService(rdb)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
_ = os.MkdirAll(cfg.DataDir, 0755)
|
|
reg := cart.NewCartMultationRegistry(cart.NewCartMutationContext(nil))
|
|
diskStorage := actor.NewDiskStorage[cart.CartGrain](cfg.DataDir, reg)
|
|
|
|
_ = os.MkdirAll(cfg.CheckoutDataDir, 0755)
|
|
regCheckout := checkout.NewCheckoutMutationRegistry(checkout.NewCheckoutMutationContext())
|
|
diskStorageCheckout := actor.NewDiskStorage[checkout.CheckoutGrain](cfg.CheckoutDataDir, regCheckout)
|
|
|
|
// Optional customer/profile storage.
|
|
var customerSrv *CustomerServer
|
|
if cfg.ProfileDataDir != "" {
|
|
_ = os.MkdirAll(cfg.ProfileDataDir, 0755)
|
|
regProfile := profile.NewProfileMutationRegistry()
|
|
profileStorage := actor.NewDiskStorage[profile.ProfileGrain](cfg.ProfileDataDir, regProfile)
|
|
customerSrv = NewCustomerServer(cfg.ProfileDataDir, profileStorage)
|
|
}
|
|
|
|
return &App{
|
|
fs: NewFileServer(cfg.DataDir, cfg.CheckoutDataDir, diskStorage, diskStorageCheckout),
|
|
hub: NewHub(),
|
|
rdb: rdb,
|
|
inv: inventoryService,
|
|
cs: customerSrv,
|
|
}, nil
|
|
}
|
|
|
|
// RegisterRoutes registers the commerce admin HTTP surface on mux. It does not
|
|
// apply auth or CORS — the composing host (or standalone main) wraps the mux
|
|
// with those.
|
|
func (a *App) RegisterRoutes(mux *http.ServeMux) {
|
|
mux.HandleFunc("GET /carts", a.fs.CartsHandler)
|
|
mux.HandleFunc("GET /cart/{id}", a.fs.CartHandler)
|
|
mux.HandleFunc("GET /checkouts", a.fs.CheckoutsHandler)
|
|
mux.HandleFunc("GET /checkout/{id}", a.fs.CheckoutHandler)
|
|
mux.HandleFunc("PUT /inventory/{locationId}/{sku}", a.updateInventory)
|
|
mux.HandleFunc("/promotions", a.fs.PromotionsHandler)
|
|
mux.HandleFunc("/vouchers", a.fs.VoucherHandler)
|
|
mux.HandleFunc("/promotion/{id}", a.fs.PromotionPartHandler)
|
|
mux.HandleFunc("/ws", a.hub.ServeWS)
|
|
// Optional customer endpoints (only mounted when ProfileDataDir is configured).
|
|
if a.cs != nil {
|
|
a.cs.RegisterRoutes(mux)
|
|
}
|
|
}
|
|
|
|
func (a *App) updateInventory(w http.ResponseWriter, r *http.Request) {
|
|
locationID := inventory.LocationID(r.PathValue("locationId"))
|
|
sku := inventory.SKU(r.PathValue("sku"))
|
|
pipe := a.rdb.Pipeline()
|
|
var payload struct {
|
|
Quantity int64 `json:"quantity"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
|
|
http.Error(w, "invalid payload", http.StatusBadRequest)
|
|
return
|
|
}
|
|
a.inv.UpdateInventory(r.Context(), pipe, sku, locationID, payload.Quantity)
|
|
if _, err := pipe.Exec(r.Context()); err != nil {
|
|
http.Error(w, "failed to update inventory", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if err := a.inv.SendInventoryChanged(r.Context(), sku, locationID); err != nil {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
// Start runs the WebSocket hub loop and, when conn is non-nil, the RabbitMQ
|
|
// mutation consumer that broadcasts cart mutations to connected clients. The
|
|
// background goroutines stop when ctx is cancelled.
|
|
func (a *App) Start(ctx context.Context, conn *amqp.Connection) error {
|
|
go a.hub.Run()
|
|
if conn != nil {
|
|
if err := startMutationConsumer(ctx, conn, a.hub); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Shutdown releases the App's resources (the Redis client). The background
|
|
// goroutines are stopped by cancelling the ctx passed to Start.
|
|
func (a *App) Shutdown(_ context.Context) error {
|
|
return a.rdb.Close()
|
|
}
|
|
|
|
// startMutationConsumer subscribes to the cart "mutation" topic and forwards
|
|
// each message to the hub for broadcast over WebSocket. Best-effort: a full hub
|
|
// queue drops the message rather than blocking.
|
|
func startMutationConsumer(ctx context.Context, conn *amqp.Connection, hub *Hub) error {
|
|
ch, err := conn.Channel()
|
|
if err != nil {
|
|
_ = conn.Close()
|
|
return err
|
|
}
|
|
msgs, err := messaging.DeclareBindAndConsume(ch, "cart", "mutation")
|
|
if err != nil {
|
|
_ = ch.Close()
|
|
return err
|
|
}
|
|
|
|
go func() {
|
|
defer ch.Close()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case m, ok := <-msgs:
|
|
if !ok {
|
|
log.Printf("mutation consumer: channel closed")
|
|
return
|
|
}
|
|
log.Printf("mutation event: %s", string(m.Body))
|
|
if hub != nil {
|
|
select {
|
|
case hub.broadcast <- m.Body:
|
|
default:
|
|
// hub queue full: drop to avoid blocking
|
|
}
|
|
}
|
|
if err := m.Ack(false); err != nil {
|
|
log.Printf("error acknowledging message: %v", err)
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
return nil
|
|
}
|