478 lines
15 KiB
Go
478 lines
15 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"strconv"
|
|
"time"
|
|
|
|
messages "git.tornberg.me/go-cart-actor/proto"
|
|
)
|
|
|
|
type PoolServer struct {
|
|
pod_name string
|
|
pool GrainPool
|
|
}
|
|
|
|
func NewPoolServer(pool GrainPool, pod_name string) *PoolServer {
|
|
return &PoolServer{
|
|
pod_name: pod_name,
|
|
pool: pool,
|
|
}
|
|
}
|
|
|
|
func (s *PoolServer) process(id CartId, mutation interface{}) (*CartGrain, error) {
|
|
grain, err := s.pool.Apply(id, mutation)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return grain, nil
|
|
}
|
|
|
|
func (s *PoolServer) HandleGet(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
grain, err := s.pool.Get(id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return s.WriteResult(w, grain)
|
|
}
|
|
|
|
func (s *PoolServer) HandleAddSku(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
sku := r.PathValue("sku")
|
|
data, err := s.process(id, &messages.AddRequest{Sku: sku, Quantity: 1})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.WriteResult(w, data)
|
|
}
|
|
|
|
func ErrorHandler(fn func(w http.ResponseWriter, r *http.Request) error) func(w http.ResponseWriter, r *http.Request) {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
err := fn(w, r)
|
|
if err != nil {
|
|
log.Printf("Server error, not remote error: %v\n", err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte(err.Error()))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *PoolServer) WriteResult(w http.ResponseWriter, result *CartGrain) error {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Header().Set("Cache-Control", "no-cache")
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
w.Header().Set("X-Pod-Name", s.pod_name)
|
|
if result == nil {
|
|
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
|
|
return nil
|
|
}
|
|
w.WriteHeader(http.StatusOK)
|
|
enc := json.NewEncoder(w)
|
|
err := enc.Encode(result)
|
|
return err
|
|
}
|
|
|
|
func (s *PoolServer) HandleDeleteItem(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
|
|
itemIdString := r.PathValue("itemId")
|
|
itemId, err := strconv.Atoi(itemIdString)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
data, err := s.process(id, &messages.RemoveItem{Id: int64(itemId)})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.WriteResult(w, data)
|
|
}
|
|
|
|
type SetDelivery struct {
|
|
Provider string `json:"provider"`
|
|
Items []int64 `json:"items"`
|
|
PickupPoint *messages.PickupPoint `json:"pickupPoint,omitempty"`
|
|
}
|
|
|
|
func (s *PoolServer) HandleSetDelivery(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
|
|
delivery := SetDelivery{}
|
|
err := json.NewDecoder(r.Body).Decode(&delivery)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
data, err := s.process(id, &messages.SetDelivery{
|
|
Provider: delivery.Provider,
|
|
Items: delivery.Items,
|
|
PickupPoint: delivery.PickupPoint,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.WriteResult(w, data)
|
|
}
|
|
|
|
func (s *PoolServer) HandleSetPickupPoint(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
|
|
deliveryIdString := r.PathValue("deliveryId")
|
|
deliveryId, err := strconv.Atoi(deliveryIdString)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pickupPoint := messages.PickupPoint{}
|
|
err = json.NewDecoder(r.Body).Decode(&pickupPoint)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
reply, err := s.process(id, &messages.SetPickupPoint{
|
|
DeliveryId: int64(deliveryId),
|
|
Id: pickupPoint.Id,
|
|
Name: pickupPoint.Name,
|
|
Address: pickupPoint.Address,
|
|
City: pickupPoint.City,
|
|
Zip: pickupPoint.Zip,
|
|
Country: pickupPoint.Country,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.WriteResult(w, reply)
|
|
}
|
|
|
|
func (s *PoolServer) HandleRemoveDelivery(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
|
|
deliveryIdString := r.PathValue("deliveryId")
|
|
deliveryId, err := strconv.Atoi(deliveryIdString)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
reply, err := s.process(id, &messages.RemoveDelivery{Id: int64(deliveryId)})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.WriteResult(w, reply)
|
|
}
|
|
|
|
func (s *PoolServer) HandleQuantityChange(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
changeQuantity := messages.ChangeQuantity{}
|
|
err := json.NewDecoder(r.Body).Decode(&changeQuantity)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
reply, err := s.process(id, &changeQuantity)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.WriteResult(w, reply)
|
|
}
|
|
|
|
func (s *PoolServer) HandleSetCartItems(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
setCartItems := messages.SetCartRequest{}
|
|
err := json.NewDecoder(r.Body).Decode(&setCartItems)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
reply, err := s.process(id, &setCartItems)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.WriteResult(w, reply)
|
|
}
|
|
|
|
func (s *PoolServer) HandleAddRequest(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
addRequest := messages.AddRequest{}
|
|
err := json.NewDecoder(r.Body).Decode(&addRequest)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
reply, err := s.process(id, &addRequest)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.WriteResult(w, reply)
|
|
}
|
|
|
|
func (s *PoolServer) HandleConfirmation(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
orderId := r.PathValue("orderId")
|
|
if orderId == "" {
|
|
return fmt.Errorf("orderId is empty")
|
|
}
|
|
order, err := KlarnaInstance.GetOrder(orderId)
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Header().Set("X-Pod-Name", s.pod_name)
|
|
w.Header().Set("Cache-Control", "no-cache")
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
w.WriteHeader(http.StatusOK)
|
|
return json.NewEncoder(w).Encode(order)
|
|
}
|
|
|
|
func (s *PoolServer) CreateOrUpdateCheckout(host string, id CartId) (*CheckoutOrder, error) {
|
|
meta := &CheckoutMeta{
|
|
Terms: fmt.Sprintf("https://%s/terms", host),
|
|
Checkout: fmt.Sprintf("https://%s/checkout?order_id={checkout.order.id}", host),
|
|
Confirmation: fmt.Sprintf("https://%s/confirmation/{checkout.order.id}", host),
|
|
Validation: fmt.Sprintf("https://%s/validate", host),
|
|
Push: fmt.Sprintf("https://%s/push?order_id={checkout.order.id}", host),
|
|
Country: getCountryFromHost(host),
|
|
}
|
|
|
|
// Get current grain state (may be local or remote)
|
|
grain, err := s.pool.Get(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Build pure checkout payload
|
|
payload, _, err := BuildCheckoutOrderPayload(grain, meta)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if grain.OrderReference != "" {
|
|
return KlarnaInstance.UpdateOrder(grain.OrderReference, bytes.NewReader(payload))
|
|
} else {
|
|
return KlarnaInstance.CreateOrder(bytes.NewReader(payload))
|
|
}
|
|
}
|
|
|
|
func (s *PoolServer) ApplyCheckoutStarted(klarnaOrder *CheckoutOrder, id CartId) (*CartGrain, error) {
|
|
// Persist initialization state via mutation (best-effort)
|
|
return s.pool.Apply(id, &messages.InitializeCheckout{
|
|
OrderId: klarnaOrder.ID,
|
|
Status: klarnaOrder.Status,
|
|
PaymentInProgress: true,
|
|
})
|
|
}
|
|
|
|
func (s *PoolServer) HandleCheckout(w http.ResponseWriter, r *http.Request, id CartId) error {
|
|
klarnaOrder, err := s.CreateOrUpdateCheckout(r.Host, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
s.ApplyCheckoutStarted(klarnaOrder, id)
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
return json.NewEncoder(w).Encode(klarnaOrder)
|
|
}
|
|
|
|
/*
|
|
Legacy wrapper NewCartId removed.
|
|
Use the unified generator in cart_id.go:
|
|
id, err := NewCartId()
|
|
or panic-on-error helper:
|
|
id := MustNewCartId()
|
|
*/
|
|
|
|
func CookieCartIdHandler(fn func(cartId CartId, w http.ResponseWriter, r *http.Request) error) func(w http.ResponseWriter, r *http.Request) error {
|
|
return func(w http.ResponseWriter, r *http.Request) error {
|
|
var id CartId
|
|
cookie, err := r.Cookie("cartid")
|
|
if err != nil || cookie.Value == "" {
|
|
id = MustNewCartId()
|
|
http.SetCookie(w, &http.Cookie{
|
|
Name: "cartid",
|
|
Value: id.String(),
|
|
Secure: r.TLS != nil,
|
|
HttpOnly: true,
|
|
Path: "/",
|
|
Expires: time.Now().AddDate(0, 0, 14),
|
|
SameSite: http.SameSiteLaxMode,
|
|
})
|
|
w.Header().Set("Set-Cart-Id", id.String())
|
|
} else {
|
|
parsed, ok := ParseCartId(cookie.Value)
|
|
if !ok {
|
|
id = MustNewCartId()
|
|
http.SetCookie(w, &http.Cookie{
|
|
Name: "cartid",
|
|
Value: id.String(),
|
|
Secure: r.TLS != nil,
|
|
HttpOnly: true,
|
|
Path: "/",
|
|
Expires: time.Now().AddDate(0, 0, 14),
|
|
SameSite: http.SameSiteLaxMode,
|
|
})
|
|
w.Header().Set("Set-Cart-Id", id.String())
|
|
} else {
|
|
id = parsed
|
|
}
|
|
}
|
|
// if ownershipProxyAfterExtraction != nil {
|
|
// if handled, err := ownershipProxyAfterExtraction(id, w, r); handled || err != nil {
|
|
// return err
|
|
// }
|
|
// }
|
|
return fn(id, w, r)
|
|
}
|
|
}
|
|
|
|
// Removed leftover legacy block after CookieCartIdHandler (obsolete code referencing cid/legacy)
|
|
|
|
func (s *PoolServer) RemoveCartCookie(w http.ResponseWriter, r *http.Request, cartId CartId) error {
|
|
// Clear cart cookie (breaking change: do not issue a new legacy id here)
|
|
http.SetCookie(w, &http.Cookie{
|
|
Name: "cartid",
|
|
Value: "",
|
|
Path: "/",
|
|
Secure: r.TLS != nil,
|
|
HttpOnly: true,
|
|
Expires: time.Unix(0, 0),
|
|
SameSite: http.SameSiteLaxMode,
|
|
})
|
|
w.WriteHeader(http.StatusOK)
|
|
return nil
|
|
}
|
|
|
|
func CartIdHandler(fn func(cartId CartId, w http.ResponseWriter, r *http.Request) error) func(w http.ResponseWriter, r *http.Request) error {
|
|
return func(w http.ResponseWriter, r *http.Request) error {
|
|
raw := r.PathValue("id")
|
|
// If no id supplied, generate a new one
|
|
if raw == "" {
|
|
id := MustNewCartId()
|
|
w.Header().Set("Set-Cart-Id", id.String())
|
|
|
|
return fn(id, w, r)
|
|
}
|
|
// Parse base62 cart id
|
|
id, ok := ParseCartId(raw)
|
|
if !ok {
|
|
return fmt.Errorf("invalid cart id format")
|
|
}
|
|
|
|
return fn(id, w, r)
|
|
}
|
|
}
|
|
|
|
func (s *PoolServer) ProxyHandler(fn func(w http.ResponseWriter, r *http.Request, cartId CartId) error) func(cartId CartId, w http.ResponseWriter, r *http.Request) error {
|
|
return func(cartId CartId, w http.ResponseWriter, r *http.Request) error {
|
|
if ownerHost, ok := s.pool.OwnerHost(cartId); ok {
|
|
ok, err := ownerHost.Proxy(cartId, w, r)
|
|
if ok || err != nil {
|
|
log.Printf("proxy failed: %v", err)
|
|
// todo take ownership!!
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
// Local ownership or no owner known, proceed with local handling
|
|
|
|
return fn(w, r, cartId)
|
|
|
|
}
|
|
}
|
|
|
|
//var ownershipProxyAfterExtraction func(cartId CartId, w http.ResponseWriter, r *http.Request) (handled bool, err error)
|
|
|
|
func (s *PoolServer) Serve() *http.ServeMux {
|
|
// // Install ownership proxy hook that runs AFTER id extraction (cookie OR path)
|
|
// ownershipProxyAfterExtraction = func(cartId CartId, w http.ResponseWriter, r *http.Request) (bool, error) {
|
|
// if cartId.String() == "" {
|
|
// return false, nil
|
|
// }
|
|
// owner := s.pool.OwnerHost(cartId)
|
|
// if owner == "" || owner == s.pool.Hostname() {
|
|
// // Set / refresh cartowner cookie pointing to the local host (claim or already owned).
|
|
// localHost := owner
|
|
// if localHost == "" {
|
|
// localHost = s.pool.Hostname()
|
|
// }
|
|
// http.SetCookie(w, &http.Cookie{
|
|
// Name: "cartowner",
|
|
// Value: localHost,
|
|
// Path: "/",
|
|
// HttpOnly: true,
|
|
// SameSite: http.SameSiteLaxMode,
|
|
// })
|
|
// return false, nil
|
|
// }
|
|
// // For remote ownership set cartowner cookie to remote host for sticky sessions.
|
|
// http.SetCookie(w, &http.Cookie{
|
|
// Name: "cartowner",
|
|
// Value: owner,
|
|
// Path: "/",
|
|
// HttpOnly: true,
|
|
// SameSite: http.SameSiteLaxMode,
|
|
// })
|
|
// // Proxy logic (simplified): reuse existing request to owning host on same port.
|
|
// target := "http://" + owner + r.URL.Path
|
|
// if q := r.URL.RawQuery; q != "" {
|
|
// target += "?" + q
|
|
// }
|
|
// req, err := http.NewRequestWithContext(r.Context(), r.Method, target, r.Body)
|
|
// if err != nil {
|
|
// http.Error(w, "proxy build error", http.StatusBadGateway)
|
|
// return true, err
|
|
// }
|
|
// for k, v := range r.Header {
|
|
// for _, vv := range v {
|
|
// req.Header.Add(k, vv)
|
|
// }
|
|
// }
|
|
// req.Header.Set("X-Forwarded-Host", r.Host)
|
|
// req.Header.Set("X-Cart-Id", cartId.String())
|
|
// req.Header.Set("X-Cart-Owner", owner)
|
|
// resp, err := http.DefaultClient.Do(req)
|
|
// if err != nil {
|
|
// http.Error(w, "proxy upstream error", http.StatusBadGateway)
|
|
// return true, err
|
|
// }
|
|
// defer resp.Body.Close()
|
|
// for k, v := range resp.Header {
|
|
// for _, vv := range v {
|
|
// w.Header().Add(k, vv)
|
|
// }
|
|
// }
|
|
// w.Header().Set("X-Cart-Owner-Routed", "true")
|
|
// w.WriteHeader(resp.StatusCode)
|
|
// _, copyErr := io.Copy(w, resp.Body)
|
|
// if copyErr != nil {
|
|
// return true, copyErr
|
|
// }
|
|
// return true, nil
|
|
// }
|
|
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("OPTIONS /", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Access-Control-Allow-Origin", "*")
|
|
w.Header().Set("Access-Control-Allow-Methods", "GET, PUT, POST, DELETE")
|
|
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
|
w.WriteHeader(http.StatusOK)
|
|
})
|
|
|
|
mux.HandleFunc("GET /", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleGet))))
|
|
mux.HandleFunc("GET /add/{sku}", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleAddSku))))
|
|
mux.HandleFunc("POST /", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleAddRequest))))
|
|
mux.HandleFunc("POST /set", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleSetCartItems))))
|
|
mux.HandleFunc("DELETE /{itemId}", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleDeleteItem))))
|
|
mux.HandleFunc("PUT /", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleQuantityChange))))
|
|
mux.HandleFunc("DELETE /", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.RemoveCartCookie))))
|
|
mux.HandleFunc("POST /delivery", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleSetDelivery))))
|
|
mux.HandleFunc("DELETE /delivery/{deliveryId}", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleRemoveDelivery))))
|
|
mux.HandleFunc("PUT /delivery/{deliveryId}/pickupPoint", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleSetPickupPoint))))
|
|
mux.HandleFunc("GET /checkout", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleCheckout))))
|
|
mux.HandleFunc("GET /confirmation/{orderId}", ErrorHandler(CookieCartIdHandler(s.ProxyHandler(s.HandleConfirmation))))
|
|
|
|
mux.HandleFunc("GET /byid/{id}", ErrorHandler(CartIdHandler(s.ProxyHandler(s.HandleGet))))
|
|
mux.HandleFunc("GET /byid/{id}/add/{sku}", ErrorHandler(CartIdHandler(s.ProxyHandler(s.HandleAddSku))))
|
|
mux.HandleFunc("POST /byid/{id}", ErrorHandler(CartIdHandler(s.ProxyHandler(s.HandleAddRequest))))
|
|
mux.HandleFunc("DELETE /byid/{id}/{itemId}", ErrorHandler(CartIdHandler(s.ProxyHandler(s.HandleDeleteItem))))
|
|
mux.HandleFunc("PUT /byid/{id}", ErrorHandler(CartIdHandler(s.ProxyHandler(s.HandleQuantityChange))))
|
|
mux.HandleFunc("POST /byid/{id}/delivery", ErrorHandler(CartIdHandler(s.ProxyHandler(s.HandleSetDelivery))))
|
|
mux.HandleFunc("DELETE /byid/{id}/delivery/{deliveryId}", ErrorHandler(CartIdHandler(s.ProxyHandler(s.HandleRemoveDelivery))))
|
|
mux.HandleFunc("PUT /byid/{id}/delivery/{deliveryId}/pickupPoint", ErrorHandler(CartIdHandler(s.ProxyHandler(s.HandleSetPickupPoint))))
|
|
mux.HandleFunc("GET /byid/{id}/checkout", ErrorHandler(CartIdHandler(s.ProxyHandler(s.HandleCheckout))))
|
|
mux.HandleFunc("GET /byid/{id}/confirmation", ErrorHandler(CartIdHandler(s.ProxyHandler(s.HandleConfirmation))))
|
|
|
|
return mux
|
|
}
|