refactor/checkout (#8)

Co-authored-by: matst80 <mats.tornberg@gmail.com>
Reviewed-on: #8
Co-authored-by: Mats Törnberg <mats@tornberg.me>
Co-committed-by: Mats Törnberg <mats@tornberg.me>

cmd/cart/amqp-order-handler.go

@@ -1,64 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	amqp "github.com/rabbitmq/amqp091-go"
-)
-
-type AmqpOrderHandler struct {
-	conn  *amqp.Connection
-	queue *amqp.Queue
-}
-
-func NewAmqpOrderHandler(conn *amqp.Connection) *AmqpOrderHandler {
-	return &AmqpOrderHandler{
-		conn: conn,
-	}
-}
-
-func (h *AmqpOrderHandler) DefineQueue() error {
-	ch, err := h.conn.Channel()
-	if err != nil {
-		return fmt.Errorf("failed to open a channel: %w", err)
-	}
-	defer ch.Close()
-
-	queue, err := ch.QueueDeclare(
-		"order-queue", // name
-		false,
-		false,
-		false,
-		false,
-		nil,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to declare an exchange: %w", err)
-	}
-	h.queue = &queue
-	return nil
-}
-
-func (h *AmqpOrderHandler) OrderCompleted(body []byte) error {
-	ch, err := h.conn.Channel()
-	if err != nil {
-		return fmt.Errorf("failed to open a channel: %w", err)
-	}
-	defer ch.Close()
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	return ch.PublishWithContext(ctx,
-		"",           // exchange
-		h.queue.Name, // routing key
-		false,        // mandatory
-		false,        // immediate
-		amqp.Publishing{
-			//DeliveryMode: amqp.,
-			ContentType: "application/json",
-			Body:        body,
-		})
-
-}

cmd/cart/checkout_builder.go

@@ -1,201 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-
-	"git.k6n.net/go-cart-actor/pkg/cart"
-	"github.com/adyen/adyen-go-api-library/v21/src/checkout"
-	"github.com/adyen/adyen-go-api-library/v21/src/common"
-)
-
-// CheckoutMeta carries the external / URL metadata required to build a
-// Klarna CheckoutOrder from a CartGrain snapshot. It deliberately excludes
-// any Klarna-specific response fields (HTML snippet, client token, etc.).
-type CheckoutMeta struct {
-	SiteUrl string
-	// Terms        string
-	// Checkout     string
-	// Confirmation string
-	ClientIp string
-	Country  string
-	Currency string // optional override (defaults to "SEK" if empty)
-	Locale   string // optional override (defaults to "sv-se" if empty)
-}
-
-// BuildCheckoutOrderPayload converts the current cart grain + meta information
-// into a CheckoutOrder domain struct and returns its JSON-serialized payload
-// (to send to Klarna) alongside the structured CheckoutOrder object.
-//
-// This function is PURE: it does not perform any network I/O or mutate the
-// grain. The caller is responsible for:
-//
-//  1. Choosing whether to create or update the Klarna order.
-//  2. Invoking KlarnaClient.CreateOrder / UpdateOrder with the returned payload.
-//  3. Applying an InitializeCheckout mutation (or equivalent) with the
-//     resulting Klarna order id + status.
-//
-// If you later need to support different tax rates per line, you can extend
-// CartItem / Delivery to expose that data and propagate it here.
-func BuildCheckoutOrderPayload(grain *cart.CartGrain, meta *CheckoutMeta) ([]byte, *CheckoutOrder, error) {
-	if grain == nil {
-		return nil, nil, fmt.Errorf("nil grain")
-	}
-	if meta == nil {
-		return nil, nil, fmt.Errorf("nil checkout meta")
-	}
-
-	currency := meta.Currency
-	if currency == "" {
-		currency = "SEK"
-	}
-	locale := meta.Locale
-	if locale == "" {
-		locale = "sv-se"
-	}
-	country := meta.Country
-	if country == "" {
-		country = "SE" // sensible default; adjust if multi-country support changes
-	}
-
-	lines := make([]*Line, 0, len(grain.Items)+len(grain.Deliveries))
-
-	// Item lines
-	for _, it := range grain.Items {
-		if it == nil {
-			continue
-		}
-		lines = append(lines, &Line{
-			Type:           "physical",
-			Reference:      it.Sku,
-			Name:           it.Meta.Name,
-			Quantity:       int(it.Quantity),
-			UnitPrice:      int(it.Price.IncVat),
-			TaxRate:        it.Tax, // TODO: derive if variable tax rates are introduced
-			QuantityUnit:   "st",
-			TotalAmount:    int(it.TotalPrice.IncVat),
-			TotalTaxAmount: int(it.TotalPrice.TotalVat()),
-			ImageURL:       fmt.Sprintf("https://www.elgiganten.se%s", it.Meta.Image),
-		})
-	}
-
-	// Delivery lines
-	for _, d := range grain.Deliveries {
-		if d == nil || d.Price.IncVat <= 0 {
-			continue
-		}
-		lines = append(lines, &Line{
-			Type:           "shipping_fee",
-			Reference:      d.Provider,
-			Name:           "Delivery",
-			Quantity:       1,
-			UnitPrice:      int(d.Price.IncVat),
-			TaxRate:        2500,
-			QuantityUnit:   "st",
-			TotalAmount:    int(d.Price.IncVat),
-			TotalTaxAmount: int(d.Price.TotalVat()),
-		})
-	}
-
-	order := &CheckoutOrder{
-		PurchaseCountry:    country,
-		PurchaseCurrency:   currency,
-		Locale:             locale,
-		OrderAmount:        int(grain.TotalPrice.IncVat),
-		OrderTaxAmount:     int(grain.TotalPrice.TotalVat()),
-		OrderLines:         lines,
-		MerchantReference1: grain.Id.String(),
-		MerchantURLS: &CheckoutMerchantURLS{
-			Terms:        fmt.Sprintf("%s/terms", meta.SiteUrl),
-			Checkout:     fmt.Sprintf("%s/checkout?order_id={checkout.order.id}", meta.SiteUrl),
-			Confirmation: fmt.Sprintf("%s/confirmation/{checkout.order.id}", meta.SiteUrl),
-			Notification: "https://cart.k6n.net/notification",
-			Validation:   "https://cart.k6n.net/validate",
-			Push:         "https://cart.k6n.net/push?order_id={checkout.order.id}",
-		},
-	}
-
-	payload, err := json.Marshal(order)
-	if err != nil {
-		return nil, nil, fmt.Errorf("marshal checkout order: %w", err)
-	}
-
-	return payload, order, nil
-}
-
-func GetCheckoutMetaFromRequest(r *http.Request) *CheckoutMeta {
-	host := getOriginalHost(r)
-	country := getCountryFromHost(host)
-	return &CheckoutMeta{
-		ClientIp: getClientIp(r),
-		SiteUrl:  fmt.Sprintf("https://%s", host),
-		Country:  country,
-		Currency: getCurrency(country),
-		Locale:   getLocale(country),
-	}
-}
-
-func BuildAdyenCheckoutSession(grain *cart.CartGrain, meta *CheckoutMeta) (*checkout.CreateCheckoutSessionRequest, error) {
-	if grain == nil {
-		return nil, fmt.Errorf("nil grain")
-	}
-	if meta == nil {
-		return nil, fmt.Errorf("nil checkout meta")
-	}
-
-	currency := meta.Currency
-	if currency == "" {
-		currency = "SEK"
-	}
-	country := meta.Country
-	if country == "" {
-		country = "SE"
-	}
-
-	lineItems := make([]checkout.LineItem, 0, len(grain.Items)+len(grain.Deliveries))
-
-	// Item lines
-	for _, it := range grain.Items {
-		if it == nil {
-			continue
-		}
-		lineItems = append(lineItems, checkout.LineItem{
-			Quantity:           common.PtrInt64(int64(it.Quantity)),
-			AmountIncludingTax: common.PtrInt64(it.TotalPrice.IncVat),
-			Description:        common.PtrString(it.Meta.Name),
-			AmountExcludingTax: common.PtrInt64(it.TotalPrice.ValueExVat()),
-			TaxAmount:          common.PtrInt64(it.TotalPrice.TotalVat()),
-			TaxPercentage:      common.PtrInt64(int64(it.Tax)),
-		})
-	}
-
-	// Delivery lines
-	for _, d := range grain.Deliveries {
-		if d == nil || d.Price.IncVat <= 0 {
-			continue
-		}
-		lineItems = append(lineItems, checkout.LineItem{
-			Quantity:           common.PtrInt64(1),
-			AmountIncludingTax: common.PtrInt64(d.Price.IncVat),
-			Description:        common.PtrString("Delivery"),
-			AmountExcludingTax: common.PtrInt64(d.Price.ValueExVat()),
-			TaxPercentage:      common.PtrInt64(25),
-		})
-	}
-
-	return &checkout.CreateCheckoutSessionRequest{
-		Reference: grain.Id.String(),
-		Amount: checkout.Amount{
-			Value:    grain.TotalPrice.IncVat,
-			Currency: currency,
-		},
-		CountryCode:     common.PtrString(country),
-		MerchantAccount: "ElgigantenECOM",
-		Channel:         common.PtrString("Web"),
-		ShopperIP:       common.PtrString(meta.ClientIp),
-		ReturnUrl:       fmt.Sprintf("%s/adyen-return", meta.SiteUrl),
-		LineItems:       lineItems,
-	}, nil
-
-}

cmd/cart/checkout_server.go

@@ -1,210 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net/http"
-	"time"
-
-	"git.k6n.net/go-cart-actor/pkg/actor"
-	"git.k6n.net/go-cart-actor/pkg/cart"
-	"git.k6n.net/go-cart-actor/pkg/messages"
-
-	"github.com/matst80/go-redis-inventory/pkg/inventory"
-	amqp "github.com/rabbitmq/amqp091-go"
-)
-
-var tpl = `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>s10r testing - checkout</title>
-  </head>
-
-  <body>
-    %s
-  </body>
-</html>
-`
-
-func (a *App) getGrainFromOrder(ctx context.Context, order *CheckoutOrder) (*cart.CartGrain, error) {
-	cartId, ok := cart.ParseCartId(order.MerchantReference1)
-	if !ok {
-		return nil, fmt.Errorf("invalid cart id in order reference: %s", order.MerchantReference1)
-	}
-	grain, err := a.pool.Get(ctx, uint64(cartId))
-	if err != nil {
-		return nil, fmt.Errorf("failed to get cart grain: %w", err)
-	}
-	return grain, nil
-}
-
-func (a *App) HandleCheckoutRequests(amqpUrl string, mux *http.ServeMux, inventoryService inventory.InventoryService) {
-	conn, err := amqp.Dial(amqpUrl)
-	if err != nil {
-		log.Fatalf("failed to connect to RabbitMQ: %v", err)
-	}
-
-	amqpListener := actor.NewAmqpListener(conn, func(id uint64, msg []actor.ApplyResult) (any, error) {
-		return &CartChangeEvent{
-			CartId:    cart.CartId(id),
-			Mutations: msg,
-		}, nil
-	})
-	amqpListener.DefineTopics()
-	a.pool.AddListener(amqpListener)
-	orderHandler := NewAmqpOrderHandler(conn)
-	orderHandler.DefineQueue()
-
-	mux.HandleFunc("/push", func(w http.ResponseWriter, r *http.Request) {
-		log.Printf("Klarna order confirmation push, method: %s", r.Method)
-		if r.Method != http.MethodPost {
-			w.WriteHeader(http.StatusMethodNotAllowed)
-			return
-		}
-		orderId := r.URL.Query().Get("order_id")
-		log.Printf("Order confirmation push: %s", orderId)
-
-		order, err := a.klarnaClient.GetOrder(r.Context(), orderId)
-
-		if err != nil {
-			log.Printf("Error creating request: %v\n", err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		grain, err := a.getGrainFromOrder(r.Context(), order)
-		if err != nil {
-			logger.ErrorContext(r.Context(), "Unable to get grain from klarna order", "error", err.Error())
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		if inventoryService != nil {
-			inventoryRequests := getInventoryRequests(grain.Items)
-			err = inventoryService.ReserveInventory(r.Context(), inventoryRequests...)
-
-			if err != nil {
-				logger.WarnContext(r.Context(), "placeorder inventory reservation failed")
-				w.WriteHeader(http.StatusNotAcceptable)
-				return
-			}
-			a.pool.Apply(r.Context(), uint64(grain.Id), &messages.InventoryReserved{
-				Id:     grain.Id.String(),
-				Status: "success",
-			})
-		}
-
-		err = confirmOrder(r.Context(), order, orderHandler)
-		if err != nil {
-			log.Printf("Error confirming order: %v\n", err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-
-		err = triggerOrderCompleted(r.Context(), a.server, order)
-		if err != nil {
-			log.Printf("Error processing cart message: %v\n", err)
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-		err = a.klarnaClient.AcknowledgeOrder(r.Context(), orderId)
-		if err != nil {
-			log.Printf("Error acknowledging order: %v\n", err)
-		}
-
-		w.WriteHeader(http.StatusOK)
-	})
-
-	mux.HandleFunc("GET /checkout", a.server.CheckoutHandler(func(order *CheckoutOrder, w http.ResponseWriter) error {
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		w.Header().Set("Permissions-Policy", "payment=(self \"https://js.stripe.com\" \"https://m.stripe.network\" \"https://js.playground.kustom.co\")")
-		w.WriteHeader(http.StatusOK)
-		_, err := fmt.Fprintf(w, tpl, order.HTMLSnippet)
-		return err
-	}))
-
-	mux.HandleFunc("GET /confirmation/{order_id}", func(w http.ResponseWriter, r *http.Request) {
-
-		orderId := r.PathValue("order_id")
-		order, err := a.klarnaClient.GetOrder(r.Context(), orderId)
-
-		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
-			return
-		}
-
-		// Apply ConfirmationViewed mutation
-		cartId, ok := cart.ParseCartId(order.MerchantReference1)
-		if ok {
-			a.pool.Apply(r.Context(), uint64(cartId), &messages.ConfirmationViewed{})
-		}
-
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		if order.Status == "checkout_complete" {
-			http.SetCookie(w, &http.Cookie{
-				Name:     "cartid",
-				Value:    "",
-				Path:     "/",
-				Secure:   true,
-				HttpOnly: true,
-				Expires:  time.Unix(0, 0),
-				SameSite: http.SameSiteLaxMode,
-			})
-		}
-
-		w.WriteHeader(http.StatusOK)
-		fmt.Fprintf(w, tpl, order.HTMLSnippet)
-	})
-	mux.HandleFunc("/notification", func(w http.ResponseWriter, r *http.Request) {
-		log.Printf("Klarna order notification, method: %s", r.Method)
-		logger.InfoContext(r.Context(), "Klarna order notification received", "method", r.Method)
-		if r.Method != "POST" {
-			w.WriteHeader(http.StatusMethodNotAllowed)
-			return
-		}
-		order := &CheckoutOrder{}
-		err := json.NewDecoder(r.Body).Decode(order)
-		if err != nil {
-			w.WriteHeader(http.StatusBadRequest)
-		}
-		log.Printf("Klarna order notification: %s", order.ID)
-		logger.InfoContext(r.Context(), "Klarna order notification received", "order_id", order.ID)
-
-		w.WriteHeader(http.StatusOK)
-	})
-	mux.HandleFunc("POST /validate", func(w http.ResponseWriter, r *http.Request) {
-		log.Printf("Klarna order validation, method: %s", r.Method)
-		if r.Method != "POST" {
-			w.WriteHeader(http.StatusMethodNotAllowed)
-			return
-		}
-		order := &CheckoutOrder{}
-		err := json.NewDecoder(r.Body).Decode(order)
-		if err != nil {
-			w.WriteHeader(http.StatusBadRequest)
-		}
-		logger.InfoContext(r.Context(), "Klarna order validation received", "order_id", order.ID, "cart_id", order.MerchantReference1)
-		grain, err := a.getGrainFromOrder(r.Context(), order)
-		if err != nil {
-			logger.ErrorContext(r.Context(), "Unable to get grain from klarna order", "error", err.Error())
-			w.WriteHeader(http.StatusInternalServerError)
-			return
-		}
-		if inventoryService != nil {
-			inventoryRequests := getInventoryRequests(grain.Items)
-			_, err = inventoryService.ReservationCheck(r.Context(), inventoryRequests...)
-			if err != nil {
-				logger.WarnContext(r.Context(), "placeorder inventory check failed")
-				w.WriteHeader(http.StatusNotAcceptable)
-				return
-			}
-		}
-
-		w.WriteHeader(http.StatusOK)
-	})
-}

cmd/cart/k8s-host-discovery.go

@@ -6,6 +6,7 @@ import (
 	"git.k6n.net/go-cart-actor/pkg/actor"
 	"git.k6n.net/go-cart-actor/pkg/cart"
 	"git.k6n.net/go-cart-actor/pkg/discovery"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 )
@@ -24,7 +25,11 @@ func GetDiscovery() discovery.Discovery {
 	if err != nil {
 		log.Fatalf("Error creating client: %v\n", err)
 	}
-	return discovery.NewK8sDiscovery(client)
+	timeout := int64(30)
+	return discovery.NewK8sDiscovery(client, v1.ListOptions{
+		LabelSelector:  "actor-pool=cart",
+		TimeoutSeconds: &timeout,
+	})
 }
 
 func UseDiscovery(pool actor.GrainPool[*cart.CartGrain]) {

cmd/cart/klarna-client.go

@@ -1,142 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-
-	"github.com/google/uuid"
-)
-
-type KlarnaClient struct {
-	Url      string
-	UserName string
-	Password string
-	client   *http.Client
-}
-
-func NewKlarnaClient(url, userName, password string) *KlarnaClient {
-	return &KlarnaClient{
-		Url:      url,
-		UserName: userName,
-		Password: password,
-		client:   &http.Client{},
-	}
-}
-
-const (
-	KlarnaPlaygroundUrl = "https://api.playground.klarna.com"
-)
-
-func (k *KlarnaClient) GetOrder(ctx context.Context, orderId string) (*CheckoutOrder, error) {
-	req, err := http.NewRequest("GET", k.Url+"/checkout/v3/orders/"+orderId, nil)
-	if err != nil {
-		return nil, err
-	}
-	spanCtx, span := tracer.Start(ctx, "Get klarna order")
-	defer span.End()
-	req = req.WithContext(spanCtx)
-	req.Header.Add("Content-Type", "application/json")
-	req.SetBasicAuth(k.UserName, k.Password)
-
-	res, err := k.client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer res.Body.Close()
-	return k.getOrderResponse(res)
-}
-
-func (k *KlarnaClient) getOrderResponse(res *http.Response) (*CheckoutOrder, error) {
-	var err error
-	var klarnaOrderResponse CheckoutOrder
-	if res.StatusCode >= 200 && res.StatusCode <= 299 {
-		err = json.NewDecoder(res.Body).Decode(&klarnaOrderResponse)
-		if err != nil {
-			return nil, err
-		}
-		return &klarnaOrderResponse, nil
-	}
-	body, err := io.ReadAll(res.Body)
-	if err == nil {
-		log.Println(string(body))
-	}
-
-	return nil, fmt.Errorf("%s", res.Status)
-}
-
-func (k *KlarnaClient) CreateOrder(ctx context.Context, reader io.Reader) (*CheckoutOrder, error) {
-	//bytes.NewReader(reply.Payload)
-	req, err := http.NewRequest("POST", k.Url+"/checkout/v3/orders", reader)
-	if err != nil {
-		return nil, err
-	}
-	spanCtx, span := tracer.Start(ctx, "Create klarna order")
-	defer span.End()
-	req = req.WithContext(spanCtx)
-	req.Header.Add("Content-Type", "application/json")
-	req.SetBasicAuth(k.UserName, k.Password)
-
-	res, err := http.DefaultClient.Do(req)
-	if nil != err {
-		return nil, err
-	}
-	defer res.Body.Close()
-	return k.getOrderResponse(res)
-}
-
-func (k *KlarnaClient) UpdateOrder(ctx context.Context, orderId string, reader io.Reader) (*CheckoutOrder, error) {
-	//bytes.NewReader(reply.Payload)
-	req, err := http.NewRequest("POST", fmt.Sprintf("%s/checkout/v3/orders/%s", k.Url, orderId), reader)
-	if err != nil {
-		return nil, err
-	}
-
-	spanCtx, span := tracer.Start(ctx, "Update klarna order")
-	defer span.End()
-	req = req.WithContext(spanCtx)
-	req.Header.Add("Content-Type", "application/json")
-	req.SetBasicAuth(k.UserName, k.Password)
-
-	res, err := http.DefaultClient.Do(req)
-	if nil != err {
-		return nil, err
-	}
-	defer res.Body.Close()
-	return k.getOrderResponse(res)
-}
-
-func (k *KlarnaClient) AbortOrder(ctx context.Context, orderId string) error {
-	req, err := http.NewRequest("POST", fmt.Sprintf("%s/checkout/v3/orders/%s/abort", k.Url, orderId), nil)
-	if err != nil {
-		return err
-	}
-	spanCtx, span := tracer.Start(ctx, "Abort klarna order")
-	defer span.End()
-	req = req.WithContext(spanCtx)
-	req.SetBasicAuth(k.UserName, k.Password)
-
-	_, err = http.DefaultClient.Do(req)
-	return err
-}
-
-// ordermanagement/v1/orders/{order_id}/acknowledge
-func (k *KlarnaClient) AcknowledgeOrder(ctx context.Context, orderId string) error {
-	req, err := http.NewRequest("POST", fmt.Sprintf("%s/ordermanagement/v1/orders/%s/acknowledge", k.Url, orderId), nil)
-	if err != nil {
-		return err
-	}
-	spanCtx, span := tracer.Start(ctx, "Acknowledge klarna order")
-	defer span.End()
-	req = req.WithContext(spanCtx)
-	id := uuid.New()
-
-	req.SetBasicAuth(k.UserName, k.Password)
-	req.Header.Add("Klarna-Idempotency-Key", id.String())
-
-	_, err = http.DefaultClient.Do(req)
-	return err
-}

cmd/cart/klarna-types.go

@@ -1,169 +0,0 @@
-package main
-
-type (
-	LineType string
-
-	// CheckoutOrder type is the request structure to create a new order from the Checkout API
-	CheckoutOrder struct {
-		ID                     string                `json:"order_id,omitempty"`
-		PurchaseCountry        string                `json:"purchase_country"`
-		PurchaseCurrency       string                `json:"purchase_currency"`
-		Locale                 string                `json:"locale"`
-		Status                 string                `json:"status,omitempty"`
-		BillingAddress         *Address              `json:"billing_address,omitempty"`
-		ShippingAddress        *Address              `json:"shipping_address,omitempty"`
-		OrderAmount            int                   `json:"order_amount"`
-		OrderTaxAmount         int                   `json:"order_tax_amount"`
-		OrderLines             []*Line               `json:"order_lines"`
-		Customer               *CheckoutCustomer     `json:"customer,omitempty"`
-		MerchantURLS           *CheckoutMerchantURLS `json:"merchant_urls"`
-		HTMLSnippet            string                `json:"html_snippet,omitempty"`
-		MerchantReference1     string                `json:"merchant_reference1,omitempty"`
-		MerchantReference2     string                `json:"merchant_reference2,omitempty"`
-		StartedAt              string                `json:"started_at,omitempty"`
-		CompletedAt            string                `json:"completed_at,omitempty"`
-		LastModifiedAt         string                `json:"last_modified_at,omitempty"`
-		Options                *CheckoutOptions      `json:"options,omitempty"`
-		Attachment             *Attachment           `json:"attachment,omitempty"`
-		ExternalPaymentMethods []*PaymentProvider    `json:"external_payment_methods,omitempty"`
-		ExternalCheckouts      []*PaymentProvider    `json:"external_checkouts,omitempty"`
-		ShippingCountries      []string              `json:"shipping_countries,omitempty"`
-		ShippingOptions        []*ShippingOption     `json:"shipping_options,omitempty"`
-		MerchantData           string                `json:"merchant_data,omitempty"`
-		GUI                    *GUI                  `json:"gui,omitempty"`
-		MerchantRequested      *AdditionalCheckBox   `json:"merchant_requested,omitempty"`
-		SelectedShippingOption *ShippingOption       `json:"selected_shipping_option,omitempty"`
-		ErrorCode              string                `json:"error_code,omitempty"`
-		ErrorMessages          []string              `json:"error_messages,omitempty"`
-	}
-
-	// GUI type wraps the GUI options
-	GUI struct {
-		Options []string `json:"options,omitempty"`
-	}
-
-	// ShippingOption type is part of the CheckoutOrder structure, represent the shipping options field
-	ShippingOption struct {
-		ID             string `json:"id"`
-		Name           string `json:"name"`
-		Description    string `json:"description,omitempty"`
-		Promo          string `json:"promo,omitempty"`
-		Price          int    `json:"price"`
-		TaxAmount      int    `json:"tax_amount"`
-		TaxRate        int    `json:"tax_rate"`
-		Preselected    bool   `json:"preselected,omitempty"`
-		ShippingMethod string `json:"shipping_method,omitempty"`
-	}
-
-	// PaymentProvider type is part of the CheckoutOrder structure, represent the ExternalPaymentMethods and
-	// ExternalCheckouts field
-	PaymentProvider struct {
-		Name        string   `json:"name"`
-		RedirectURL string   `json:"redirect_url"`
-		ImageURL    string   `json:"image_url,omitempty"`
-		Fee         int      `json:"fee,omitempty"`
-		Description string   `json:"description,omitempty"`
-		Countries   []string `json:"countries,omitempty"`
-	}
-
-	Attachment struct {
-		ContentType string `json:"content_type"`
-		Body        string `json:"body"`
-	}
-
-	CheckoutOptions struct {
-		AcquiringChannel               string              `json:"acquiring_channel,omitempty"`
-		AllowSeparateShippingAddress   bool                `json:"allow_separate_shipping_address,omitempty"`
-		ColorButton                    string              `json:"color_button,omitempty"`
-		ColorButtonText                string              `json:"color_button_text,omitempty"`
-		ColorCheckbox                  string              `json:"color_checkbox,omitempty"`
-		ColorCheckboxCheckmark         string              `json:"color_checkbox_checkmark,omitempty"`
-		ColorHeader                    string              `json:"color_header,omitempty"`
-		ColorLink                      string              `json:"color_link,omitempty"`
-		DateOfBirthMandatory           bool                `json:"date_of_birth_mandatory,omitempty"`
-		ShippingDetails                string              `json:"shipping_details,omitempty"`
-		TitleMandatory                 bool                `json:"title_mandatory,omitempty"`
-		AdditionalCheckbox             *AdditionalCheckBox `json:"additional_checkbox"`
-		RadiusBorder                   string              `json:"radius_border,omitempty"`
-		ShowSubtotalDetail             bool                `json:"show_subtotal_detail,omitempty"`
-		RequireValidateCallbackSuccess bool                `json:"require_validate_callback_success,omitempty"`
-		AllowGlobalBillingCountries    bool                `json:"allow_global_billing_countries,omitempty"`
-	}
-
-	AdditionalCheckBox struct {
-		Text     string `json:"text"`
-		Checked  bool   `json:"checked"`
-		Required bool   `json:"required"`
-	}
-
-	CheckoutMerchantURLS struct {
-		// URL of merchant terms and conditions. Should be different than checkout, confirmation and push URLs.
-		// (max 2000 characters)
-		Terms string `json:"terms"`
-
-		// URL of merchant checkout page. Should be different than terms, confirmation and push URLs.
-		// (max 2000 characters)
-		Checkout string `json:"checkout"`
-
-		// URL of merchant confirmation page. Should be different than checkout and confirmation URLs.
-		// (max 2000 characters)
-		Confirmation string `json:"confirmation"`
-
-		// URL that will be requested when an order is completed. Should be different than checkout and
-		// confirmation URLs. (max 2000 characters)
-		Push string `json:"push"`
-		// URL that will be requested for final merchant validation. (must be https, max 2000 characters)
-		Validation string `json:"validation,omitempty"`
-
-		// URL for shipping option update. (must be https, max 2000 characters)
-		ShippingOptionUpdate string `json:"shipping_option_update,omitempty"`
-
-		// URL for shipping, tax and purchase currency updates. Will be called on address changes.
-		// (must be https, max 2000 characters)
-		AddressUpdate string `json:"address_update,omitempty"`
-
-		// URL for notifications on pending orders. (max 2000 characters)
-		Notification string `json:"notification,omitempty"`
-
-		// URL for shipping, tax and purchase currency updates. Will be called on purchase country changes.
-		// (must be https, max 2000 characters)
-		CountryChange string `json:"country_change,omitempty"`
-	}
-
-	CheckoutCustomer struct {
-		// DateOfBirth in string representation 2006-01-02
-		DateOfBirth string `json:"date_of_birth"`
-	}
-
-	// Address type define the address object (json serializable) being used for the API to represent billing &
-	// shipping addresses
-	Address struct {
-		GivenName      string `json:"given_name,omitempty"`
-		FamilyName     string `json:"family_name,omitempty"`
-		Email          string `json:"email,omitempty"`
-		Title          string `json:"title,omitempty"`
-		StreetAddress  string `json:"street_address,omitempty"`
-		StreetAddress2 string `json:"street_address2,omitempty"`
-		PostalCode     string `json:"postal_code,omitempty"`
-		City           string `json:"city,omitempty"`
-		Region         string `json:"region,omitempty"`
-		Phone          string `json:"phone,omitempty"`
-		Country        string `json:"country,omitempty"`
-	}
-
-	Line struct {
-		Type                string `json:"type,omitempty"`
-		Reference           string `json:"reference,omitempty"`
-		Name                string `json:"name"`
-		Quantity            int    `json:"quantity"`
-		QuantityUnit        string `json:"quantity_unit,omitempty"`
-		UnitPrice           int    `json:"unit_price"`
-		TaxRate             int    `json:"tax_rate"`
-		TotalAmount         int    `json:"total_amount"`
-		TotalDiscountAmount int    `json:"total_discount_amount,omitempty"`
-		TotalTaxAmount      int    `json:"total_tax_amount"`
-		MerchantData        string `json:"merchant_data,omitempty"`
-		ProductURL          string `json:"product_url,omitempty"`
-		ImageURL            string `json:"image_url,omitempty"`
-	}
-)

cmd/cart/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"log"
 	"net"
@@ -15,12 +14,9 @@ import (
 
 	"git.k6n.net/go-cart-actor/pkg/actor"
 	"git.k6n.net/go-cart-actor/pkg/cart"
-	messages "git.k6n.net/go-cart-actor/pkg/messages"
 	"git.k6n.net/go-cart-actor/pkg/promotions"
 	"git.k6n.net/go-cart-actor/pkg/proxy"
 	"git.k6n.net/go-cart-actor/pkg/voucher"
-	"github.com/adyen/adyen-go-api-library/v21/src/adyen"
-	"github.com/adyen/adyen-go-api-library/v21/src/common"
 	"github.com/matst80/go-redis-inventory/pkg/inventory"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
@@ -41,9 +37,8 @@ func init() {
 }
 
 type App struct {
-	pool         *actor.SimpleGrainPool[cart.CartGrain]
-	server       *PoolServer
-	klarnaClient *KlarnaClient
+	pool   *actor.SimpleGrainPool[cart.CartGrain]
+	server *PoolServer
 }
 
 var podIp = os.Getenv("POD_IP")
@@ -195,30 +190,16 @@ func main() {
 		log.Fatalf("Error creating cart pool: %v\n", err)
 	}
 
-	adyenClient := adyen.NewClient(&common.Config{
-		ApiKey:      os.Getenv("ADYEN_API_KEY"),
-		Environment: common.TestEnv,
-	})
-
-	klarnaClient := NewKlarnaClient(KlarnaPlaygroundUrl, os.Getenv("KLARNA_API_USERNAME"), os.Getenv("KLARNA_API_PASSWORD"))
-
-	syncedServer := NewPoolServer(pool, fmt.Sprintf("%s, %s", name, podIp), klarnaClient, inventoryService, inventoryReservationService, adyenClient)
+	syncedServer := NewPoolServer(pool, fmt.Sprintf("%s, %s", name, podIp), inventoryService, inventoryReservationService)
 
 	app := &App{
-		pool:         pool,
-		server:       syncedServer,
-		klarnaClient: klarnaClient,
+		pool:   pool,
+		server: syncedServer,
 	}
 
 	mux := http.NewServeMux()
 	debugMux := http.NewServeMux()
 
-	if amqpUrl == "" {
-		log.Printf("no connection to amqp defined")
-	} else {
-		app.HandleCheckoutRequests(amqpUrl, mux, inventoryService)
-	}
-
 	grpcSrv, err := actor.NewControlServer[*cart.CartGrain](controlPlaneConfig, pool)
 	if err != nil {
 		log.Fatalf("Error starting control plane gRPC server: %v\n", err)
@@ -331,31 +312,3 @@ func main() {
 	}
 
 }
-
-func triggerOrderCompleted(ctx context.Context, syncedServer *PoolServer, order *CheckoutOrder) error {
-	mutation := &messages.OrderCreated{
-		OrderId: order.ID,
-		Status:  order.Status,
-	}
-	cid, ok := cart.ParseCartId(order.MerchantReference1)
-	if !ok {
-		return fmt.Errorf("invalid cart id in order reference: %s", order.MerchantReference1)
-	}
-	_, applyErr := syncedServer.Apply(ctx, uint64(cid), mutation)
-
-	return applyErr
-}
-
-func confirmOrder(ctx context.Context, order *CheckoutOrder, orderHandler *AmqpOrderHandler) error {
-	orderToSend, err := json.Marshal(order)
-	if err != nil {
-		return err
-	}
-
-	err = orderHandler.OrderCompleted(orderToSend)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

cmd/cart/pool-server.go

@@ -1,29 +1,20 @@
 package main
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
-	"fmt"
+	"io"
 	"log"
 	"net/http"
-	"net/url"
-	"os"
 	"strconv"
 	"sync"
 	"time"
 
 	"git.k6n.net/go-cart-actor/pkg/actor"
 	"git.k6n.net/go-cart-actor/pkg/cart"
-	messages "git.k6n.net/go-cart-actor/pkg/messages"
-	"git.k6n.net/go-cart-actor/pkg/proxy"
+	messages "git.k6n.net/go-cart-actor/proto/cart"
+
 	"git.k6n.net/go-cart-actor/pkg/voucher"
-	"github.com/adyen/adyen-go-api-library/v21/src/adyen"
-	"github.com/adyen/adyen-go-api-library/v21/src/checkout"
-	"github.com/adyen/adyen-go-api-library/v21/src/common"
-	"github.com/adyen/adyen-go-api-library/v21/src/hmacvalidator"
-	"github.com/adyen/adyen-go-api-library/v21/src/webhook"
-	"github.com/google/uuid"
 	"github.com/matst80/go-redis-inventory/pkg/inventory"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
@@ -52,20 +43,16 @@ var (
 type PoolServer struct {
 	actor.GrainPool[*cart.CartGrain]
 	pod_name           string
-	klarnaClient       *KlarnaClient
-	adyenClient        *adyen.APIClient
 	inventoryService   inventory.InventoryService
 	reservationService inventory.CartReservationService
 }
 
-func NewPoolServer(pool actor.GrainPool[*cart.CartGrain], pod_name string, klarnaClient *KlarnaClient, inventoryService inventory.InventoryService, inventoryReservationService inventory.CartReservationService, adyenClient *adyen.APIClient) *PoolServer {
+func NewPoolServer(pool actor.GrainPool[*cart.CartGrain], pod_name string, inventoryService inventory.InventoryService, inventoryReservationService inventory.CartReservationService) *PoolServer {
 	srv := &PoolServer{
 		GrainPool:          pool,
 		pod_name:           pod_name,
-		klarnaClient:       klarnaClient,
 		inventoryService:   inventoryService,
 		reservationService: inventoryReservationService,
-		adyenClient:        adyenClient,
 	}
 
 	return srv
@@ -130,71 +117,6 @@ func (s *PoolServer) DeleteItemHandler(w http.ResponseWriter, r *http.Request, i
 	return s.WriteResult(w, data)
 }
 
-type SetDeliveryRequest struct {
-	Provider    string                `json:"provider"`
-	Items       []uint32              `json:"items"`
-	PickupPoint *messages.PickupPoint `json:"pickupPoint,omitempty"`
-}
-
-func (s *PoolServer) SetDeliveryHandler(w http.ResponseWriter, r *http.Request, id cart.CartId) error {
-
-	delivery := SetDeliveryRequest{}
-	err := json.NewDecoder(r.Body).Decode(&delivery)
-	if err != nil {
-		return err
-	}
-	data, err := s.ApplyLocal(r.Context(), 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) SetPickupPointHandler(w http.ResponseWriter, r *http.Request, id cart.CartId) error {
-
-	deliveryIdString := r.PathValue("deliveryId")
-	deliveryId, err := strconv.ParseInt(deliveryIdString, 10, 64)
-	if err != nil {
-		return err
-	}
-	pickupPoint := messages.PickupPoint{}
-	err = json.NewDecoder(r.Body).Decode(&pickupPoint)
-	if err != nil {
-		return err
-	}
-	reply, err := s.ApplyLocal(r.Context(), id, &messages.SetPickupPoint{
-		DeliveryId: uint32(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) RemoveDeliveryHandler(w http.ResponseWriter, r *http.Request, id cart.CartId) error {
-
-	deliveryIdString := r.PathValue("deliveryId")
-	deliveryId, err := strconv.Atoi(deliveryIdString)
-	if err != nil {
-		return err
-	}
-	reply, err := s.ApplyLocal(r.Context(), id, &messages.RemoveDelivery{Id: uint32(deliveryId)})
-	if err != nil {
-		return err
-	}
-	return s.WriteResult(w, reply)
-}
-
 func (s *PoolServer) QuantityChangeHandler(w http.ResponseWriter, r *http.Request, id cart.CartId) error {
 	changeQuantity := messages.ChangeQuantity{}
 	err := json.NewDecoder(r.Body).Decode(&changeQuantity)
@@ -282,9 +204,9 @@ type AddRequest struct {
 }
 
 func (s *PoolServer) GetReservationTime(item *messages.AddItem) time.Duration {
-
+	// TODO: Implement reservation time calculation, nil don't require reservation
 	return time.Minute * 15
-	//return nil
+
 }
 
 func (s *PoolServer) AddSkuRequestHandler(w http.ResponseWriter, r *http.Request, id cart.CartId) error {
@@ -325,99 +247,6 @@ func (s *PoolServer) AddSkuRequestHandler(w http.ResponseWriter, r *http.Request
 // 	return json.NewEncoder(w).Encode(order)
 // }
 
-func getCurrency(country string) string {
-	if country == "no" {
-		return "NOK"
-	}
-	return "SEK"
-}
-
-func getLocale(country string) string {
-	if country == "no" {
-		return "nb-no"
-	}
-	return "sv-se"
-}
-
-func getLocationId(item *cart.CartItem) inventory.LocationID {
-	if item.StoreId == nil || *item.StoreId == "" {
-		return "se"
-	}
-	return inventory.LocationID(*item.StoreId)
-}
-
-func getInventoryRequests(items []*cart.CartItem) []inventory.ReserveRequest {
-	var requests []inventory.ReserveRequest
-	for _, item := range items {
-		if item == nil {
-			continue
-		}
-		requests = append(requests, inventory.ReserveRequest{
-			InventoryReference: &inventory.InventoryReference{
-				SKU:        inventory.SKU(item.Sku),
-				LocationID: getLocationId(item),
-			},
-			Quantity: uint32(item.Quantity),
-		})
-	}
-	return requests
-}
-
-func getOriginalHost(r *http.Request) string {
-	proxyHost := r.Header.Get("X-Forwarded-Host")
-	if proxyHost != "" {
-		return proxyHost
-	}
-	return r.Host
-}
-
-func getClientIp(r *http.Request) string {
-	ip := r.Header.Get("X-Forwarded-For")
-	if ip == "" {
-		ip = r.RemoteAddr
-	}
-	return ip
-}
-
-func (s *PoolServer) CreateOrUpdateCheckout(r *http.Request, id cart.CartId) (*CheckoutOrder, error) {
-	meta := GetCheckoutMetaFromRequest(r)
-
-	// Get current grain state (may be local or remote)
-	grain, err := s.Get(r.Context(), uint64(id))
-	if err != nil {
-		return nil, err
-	}
-	if s.inventoryService != nil {
-		inventoryRequests := getInventoryRequests(grain.Items)
-		failingRequest, err := s.inventoryService.ReservationCheck(r.Context(), inventoryRequests...)
-		if err != nil {
-			logger.WarnContext(r.Context(), "inventory check failed", string(failingRequest.SKU), string(failingRequest.LocationID))
-			return nil, err
-		}
-	}
-
-	// Build pure checkout payload
-	payload, _, err := BuildCheckoutOrderPayload(grain, meta)
-	if err != nil {
-		return nil, err
-	}
-
-	if grain.OrderReference != "" {
-		return s.klarnaClient.UpdateOrder(r.Context(), grain.OrderReference, bytes.NewReader(payload))
-	} else {
-		return s.klarnaClient.CreateOrder(r.Context(), bytes.NewReader(payload))
-	}
-}
-
-func (s *PoolServer) ApplyCheckoutStarted(ctx context.Context, klarnaOrder *CheckoutOrder, id cart.CartId) (*actor.MutationResult[*cart.CartGrain], error) {
-	// Persist initialization state via mutation (best-effort)
-	return s.ApplyLocal(ctx, 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 {
@@ -431,51 +260,6 @@ func (s *PoolServer) ApplyCheckoutStarted(ctx context.Context, klarnaOrder *Chec
 // }
 //
 
-func CookieCartIdHandler(fn func(cartId cart.CartId, w http.ResponseWriter, r *http.Request) error) func(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
-		var id cart.CartId
-		cookie, err := r.Cookie("cartid")
-		if err != nil || cookie.Value == "" {
-			id = cart.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 := cart.ParseCartId(cookie.Value)
-			if !ok {
-				id = cart.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
-			}
-		}
-
-		err = fn(id, w, r)
-		if err != nil {
-			log.Printf("Server error, not remote error: %v\n", err)
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Write([]byte(err.Error()))
-		}
-
-	}
-}
-
 // Removed leftover legacy block after CookieCartIdHandler (obsolete code referencing cid/legacy)
 
 func (s *PoolServer) RemoveCartCookie(w http.ResponseWriter, r *http.Request, cartId cart.CartId) error {
@@ -493,34 +277,6 @@ func (s *PoolServer) RemoveCartCookie(w http.ResponseWriter, r *http.Request, ca
 	return nil
 }
 
-func CartIdHandler(fn func(cartId cart.CartId, w http.ResponseWriter, r *http.Request) error) func(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
-		var id cart.CartId
-		raw := r.PathValue("id")
-		// If no id supplied, generate a new one
-		if raw == "" {
-			id := cart.MustNewCartId()
-			w.Header().Set("Set-Cart-Id", id.String())
-		} else {
-			// Parse base62 cart id
-			if parsedId, ok := cart.ParseCartId(raw); !ok {
-				w.WriteHeader(http.StatusBadRequest)
-				w.Write([]byte("cart id is invalid"))
-				return
-			} else {
-				id = parsedId
-			}
-		}
-
-		err := fn(id, 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) ProxyHandler(fn func(w http.ResponseWriter, r *http.Request, cartId cart.CartId) error) func(cartId cart.CartId, w http.ResponseWriter, r *http.Request) error {
 	return func(cartId cart.CartId, w http.ResponseWriter, r *http.Request) error {
 		if ownerHost, ok := s.OwnerHost(uint64(cartId)); ok {
@@ -548,12 +304,9 @@ func (s *PoolServer) ProxyHandler(fn func(w http.ResponseWriter, r *http.Request
 
 var (
 	tracer     = otel.Tracer(name)
-	hmacKey    = os.Getenv("ADYEN_HMAC")
 	meter      = otel.Meter(name)
 	logger     = otelslog.NewLogger(name)
 	proxyCalls metric.Int64Counter
-
-// rollCnt metric.Int64Counter
 )
 
 func init() {
@@ -577,10 +330,6 @@ func (s *PoolServer) AddVoucherHandler(w http.ResponseWriter, r *http.Request, c
 	v := voucher.Service{}
 	msg, err := v.GetVoucher(data.VoucherCode)
 	if err != nil {
-		s.ApplyLocal(r.Context(), cartId, &messages.PreConditionFailed{
-			Operation: "AddVoucher",
-			Error:     err.Error(),
-		})
 		w.WriteHeader(http.StatusInternalServerError)
 		w.Write([]byte(err.Error()))
 		return err
@@ -629,26 +378,6 @@ func (s *PoolServer) SubscriptionDetailsHandler(w http.ResponseWriter, r *http.R
 	return nil
 }
 
-func (s *PoolServer) CheckoutHandler(fn func(order *CheckoutOrder, w http.ResponseWriter) error) func(w http.ResponseWriter, r *http.Request) {
-	return CookieCartIdHandler(s.ProxyHandler(func(w http.ResponseWriter, r *http.Request, cartId cart.CartId) error {
-		orderId := r.URL.Query().Get("order_id")
-		if orderId == "" {
-			order, err := s.CreateOrUpdateCheckout(r, cartId)
-			if err != nil {
-				logger.Error("unable to create klarna session", "error", err)
-				return err
-			}
-			s.ApplyCheckoutStarted(r.Context(), order, cartId)
-			return fn(order, w)
-		}
-		order, err := s.klarnaClient.GetOrder(r.Context(), orderId)
-		if err != nil {
-			return err
-		}
-		return fn(order, w)
-	}))
-}
-
 func (s *PoolServer) RemoveVoucherHandler(w http.ResponseWriter, r *http.Request, cartId cart.CartId) error {
 
 	idStr := r.PathValue("voucherId")
@@ -713,61 +442,27 @@ func (s *PoolServer) RemoveLineItemMarkingHandler(w http.ResponseWriter, r *http
 	return s.WriteResult(w, reply)
 }
 
-func (s *PoolServer) CreateCheckoutOrderHandler(w http.ResponseWriter, r *http.Request, cartId cart.CartId) error {
-	createCheckoutOrder := messages.CreateCheckoutOrder{}
-	err := json.NewDecoder(r.Body).Decode(&createCheckoutOrder)
+func (s *PoolServer) InternalApplyMutationHandler(w http.ResponseWriter, r *http.Request, cartId cart.CartId) error {
+	if r.Method != http.MethodPost {
+		w.WriteHeader(http.StatusMethodNotAllowed)
+		return nil
+	}
+	data, err := io.ReadAll(r.Body)
 	if err != nil {
 		return err
 	}
-	reply, err := s.ApplyLocal(r.Context(), cartId, &createCheckoutOrder)
+	mutation := &messages.Mutation{}
+	err = proto.Unmarshal(data, mutation)
+	if err != nil {
+		return err
+	}
+	reply, err := s.ApplyLocal(r.Context(), cartId, mutation)
 	if err != nil {
 		return err
 	}
 	return s.WriteResult(w, reply)
 }
 
-type SessionRequest struct {
-	SessionId     string `json:"sessionId"`
-	SessionResult string `json:"sessionResult"`
-	SessionData   string `json:"sessionData,omitempty"`
-}
-
-func (s *PoolServer) AdyenSessionHandler(w http.ResponseWriter, r *http.Request, cartId cart.CartId) error {
-
-	grain, err := s.Get(r.Context(), uint64(cartId))
-	if err != nil {
-		return err
-	}
-	if r.Method == http.MethodGet {
-		meta := GetCheckoutMetaFromRequest(r)
-		sessionData, err := BuildAdyenCheckoutSession(grain, meta)
-		if err != nil {
-			return err
-		}
-		service := s.adyenClient.Checkout()
-		req := service.PaymentsApi.SessionsInput().CreateCheckoutSessionRequest(*sessionData)
-		res, _, err := service.PaymentsApi.Sessions(r.Context(), req)
-		// apply checkout started
-		if err != nil {
-			return err
-		}
-		return s.WriteResult(w, res)
-	} else {
-		payload := &SessionRequest{}
-		if err := json.NewDecoder(r.Body).Decode(payload); err != nil {
-			return err
-		}
-		service := s.adyenClient.Checkout()
-		req := service.PaymentsApi.GetResultOfPaymentSessionInput(payload.SessionId).SessionResult(payload.SessionResult)
-		res, _, err := service.PaymentsApi.GetResultOfPaymentSession(r.Context(), req)
-		if err != nil {
-			return err
-		}
-		return s.WriteResult(w, res)
-	}
-
-}
-
 func (s *PoolServer) GetAnywhere(ctx context.Context, cartId cart.CartId) (*cart.CartGrain, error) {
 	id := uint64(cartId)
 	if host, isOnOtherHost := s.OwnerHost(id); isOnOtherHost {
@@ -789,164 +484,6 @@ func (s *PoolServer) ApplyAnywhere(ctx context.Context, cartId cart.CartId, msgs
 	return err
 }
 
-func (s *PoolServer) AdyenHookHandler(w http.ResponseWriter, r *http.Request) {
-	var notificationRequest webhook.Webhook
-	service := s.adyenClient.Checkout()
-	if err := json.NewDecoder(r.Body).Decode(&notificationRequest); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	cartHostMap := make(map[actor.Host][]webhook.NotificationItem)
-	for _, notificationItem := range *notificationRequest.NotificationItems {
-		item := notificationItem.NotificationRequestItem
-		log.Printf("Recieved notification event code: %s, %+v", item.EventCode, item)
-
-		isValid := hmacvalidator.ValidateHmac(item, hmacKey)
-		if !isValid {
-			log.Printf("notification hmac not valid %s, %v", item.EventCode, item)
-			http.Error(w, "Invalid HMAC", http.StatusUnauthorized)
-			return
-		} else {
-			switch item.EventCode {
-			case "CAPTURE":
-				log.Printf("Capture status: %v", item.Success)
-				// dataBytes, err := json.Marshal(item)
-				// if err != nil {
-				// 	log.Printf("error marshaling item: %v", err)
-				// 	http.Error(w, "Error marshaling item", http.StatusInternalServerError)
-				// 	return
-				// }
-				//s.ApplyAnywhere(r.Context(),0, &messages.PaymentEvent{PaymentId: item.PspReference, Success: item.Success, Name: item.EventCode, Data: &pbany.Any{Value: dataBytes}})
-			case "AUTHORISATION":
-
-				cartId, ok := cart.ParseCartId(item.MerchantReference)
-				if !ok {
-					log.Printf("invalid cart id %s", item.MerchantReference)
-					http.Error(w, "Invalid cart id", http.StatusBadRequest)
-					return
-				}
-				//s.Apply()
-
-				if host, ok := s.OwnerHost(uint64(cartId)); ok {
-					cartHostMap[host] = append(cartHostMap[host], notificationItem)
-					continue
-				}
-
-				grain, err := s.Get(r.Context(), uint64(cartId))
-				if err != nil {
-					log.Printf("Error getting cart: %v", err)
-					http.Error(w, "Cart not found", http.StatusBadRequest)
-					return
-				}
-				meta := GetCheckoutMetaFromRequest(r)
-				pspReference := item.PspReference
-				uid := uuid.New().String()
-				ref := uuid.New().String()
-				req := service.ModificationsApi.CaptureAuthorisedPaymentInput(pspReference).IdempotencyKey(uid).PaymentCaptureRequest(checkout.PaymentCaptureRequest{
-					Amount: checkout.Amount{
-						Currency: meta.Currency,
-						Value:    grain.TotalPrice.IncVat,
-					},
-					MerchantAccount: "ElgigantenECOM",
-					Reference:       &ref,
-				})
-				res, _, err := service.ModificationsApi.CaptureAuthorisedPayment(r.Context(), req)
-				if err != nil {
-					log.Printf("Error capturing payment: %v", err)
-				} else {
-					log.Printf("Payment captured successfully: %+v", res)
-					s.Apply(r.Context(), uint64(cartId), &messages.OrderCreated{
-						OrderId: res.PaymentPspReference,
-						Status:  item.EventCode,
-					})
-				}
-			default:
-				log.Printf("Unknown event code: %s", item.EventCode)
-			}
-		}
-	}
-	var failed bool = false
-	var lastMock *proxy.MockResponseWriter
-	for host, items := range cartHostMap {
-		notificationRequest.NotificationItems = &items
-		bodyBytes, err := json.Marshal(notificationRequest)
-		if err != nil {
-			log.Printf("error marshaling notification: %+v", err)
-			continue
-		}
-		customBody := bytes.NewReader(bodyBytes)
-		mockW := proxy.NewMockResponseWriter()
-		handled, err := host.Proxy(0, mockW, r, customBody)
-		if err != nil {
-			log.Printf("proxy failed for %s: %+v", host.Name(), err)
-			failed = true
-			lastMock = mockW
-		} else if handled {
-			log.Printf("notification proxied to %s", host.Name())
-		}
-	}
-	if failed {
-		w.WriteHeader(lastMock.StatusCode)
-		w.Write(lastMock.Body.Bytes())
-	} else {
-		w.WriteHeader(http.StatusAccepted)
-	}
-}
-
-func (s *PoolServer) AdyenReturnHandler(w http.ResponseWriter, r *http.Request) {
-	log.Println("Redirect received")
-
-	service := s.adyenClient.Checkout()
-
-	req := service.PaymentsApi.GetResultOfPaymentSessionInput(r.URL.Query().Get("sessionId"))
-
-	res, httpRes, err := service.PaymentsApi.GetResultOfPaymentSession(r.Context(), req)
-	log.Printf("got payment session %+v", res)
-
-	dreq := service.PaymentsApi.PaymentsDetailsInput()
-	dreq = dreq.PaymentDetailsRequest(checkout.PaymentDetailsRequest{
-		Details: checkout.PaymentCompletionDetails{
-			RedirectResult: common.PtrString(r.URL.Query().Get("redirectResult")),
-			Payload:        common.PtrString(r.URL.Query().Get("payload")),
-		},
-	})
-
-	dres, httpRes, err := service.PaymentsApi.PaymentsDetails(r.Context(), dreq)
-
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	log.Printf("Payment details response: %+v", dres)
-
-	if !common.IsNil(dres.PspReference) && *dres.PspReference != "" {
-		var redirectURL string
-		// Conditionally handle different result codes for the shopper
-		switch *dres.ResultCode {
-		case "Authorised":
-			redirectURL = "/result/success"
-		case "Pending", "Received":
-			redirectURL = "/result/pending"
-		case "Refused":
-			redirectURL = "/result/failed"
-		default:
-			reason := ""
-			if dres.RefusalReason != nil {
-				reason = *dres.RefusalReason
-			} else {
-				reason = *dres.ResultCode
-			}
-			log.Printf("Payment failed: %s", reason)
-			redirectURL = fmt.Sprintf("/result/error?reason=%s", url.QueryEscape(reason))
-		}
-		http.Redirect(w, r, redirectURL, http.StatusFound)
-		return
-	}
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(httpRes.StatusCode)
-	json.NewEncoder(w).Encode(httpRes.Status)
-}
-
 func (s *PoolServer) Serve(mux *http.ServeMux) {
 
 	// mux.HandleFunc("OPTIONS /cart", func(w http.ResponseWriter, r *http.Request) {
@@ -970,9 +507,6 @@ func (s *PoolServer) Serve(mux *http.ServeMux) {
 		}))
 	}
 
-	handleFunc("/adyen_hook", s.AdyenHookHandler)
-	handleFunc("/adyen-return", s.AdyenReturnHandler)
-
 	handleFunc("GET /cart", CookieCartIdHandler(s.ProxyHandler(s.GetCartHandler)))
 	handleFunc("GET /cart/add/{sku}", CookieCartIdHandler(s.ProxyHandler(s.AddSkuToCartHandler)))
 	handleFunc("POST /cart/add", CookieCartIdHandler(s.ProxyHandler(s.AddMultipleItemHandler)))
@@ -981,38 +515,25 @@ func (s *PoolServer) Serve(mux *http.ServeMux) {
 	handleFunc("DELETE /cart/{itemId}", CookieCartIdHandler(s.ProxyHandler(s.DeleteItemHandler)))
 	handleFunc("PUT /cart", CookieCartIdHandler(s.ProxyHandler(s.QuantityChangeHandler)))
 	handleFunc("DELETE /cart", CookieCartIdHandler(s.ProxyHandler(s.RemoveCartCookie)))
-	handleFunc("POST /cart/delivery", CookieCartIdHandler(s.ProxyHandler(s.SetDeliveryHandler)))
-	handleFunc("DELETE /cart/delivery/{deliveryId}", CookieCartIdHandler(s.ProxyHandler(s.RemoveDeliveryHandler)))
-	handleFunc("PUT /cart/delivery/{deliveryId}/pickupPoint", CookieCartIdHandler(s.ProxyHandler(s.SetPickupPointHandler)))
 	handleFunc("PUT /cart/voucher", CookieCartIdHandler(s.ProxyHandler(s.AddVoucherHandler)))
 	handleFunc("PUT /cart/subscription-details", CookieCartIdHandler(s.ProxyHandler(s.SubscriptionDetailsHandler)))
 	handleFunc("DELETE /cart/voucher/{voucherId}", CookieCartIdHandler(s.ProxyHandler(s.RemoveVoucherHandler)))
 	handleFunc("PUT /cart/user", CookieCartIdHandler(s.ProxyHandler(s.SetUserIdHandler)))
-	handleFunc("GET /cart/adyen-session", CookieCartIdHandler(s.ProxyHandler(s.AdyenSessionHandler)))
+
 	handleFunc("PUT /cart/item/{itemId}/marking", CookieCartIdHandler(s.ProxyHandler(s.LineItemMarkingHandler)))
 	handleFunc("DELETE /cart/item/{itemId}/marking", CookieCartIdHandler(s.ProxyHandler(s.RemoveLineItemMarkingHandler)))
 
-	handleFunc("POST /cart/checkout-order", CookieCartIdHandler(s.ProxyHandler(s.CreateCheckoutOrderHandler)))
-
 	//mux.HandleFunc("GET /cart/checkout", CookieCartIdHandler(s.ProxyHandler(s.HandleCheckout)))
 	//mux.HandleFunc("GET /cart/confirmation/{orderId}", CookieCartIdHandler(s.ProxyHandler(s.HandleConfirmation)))
 
 	handleFunc("GET /cart/byid/{id}", CartIdHandler(s.ProxyHandler(s.GetCartHandler)))
-	handleFunc("GET /cart/byid/{id}/add/{sku}", CartIdHandler(s.ProxyHandler(s.AddSkuToCartHandler)))
+
 	handleFunc("POST /cart/byid/{id}", CartIdHandler(s.ProxyHandler(s.AddSkuRequestHandler)))
 	handleFunc("DELETE /cart/byid/{id}/{itemId}", CartIdHandler(s.ProxyHandler(s.DeleteItemHandler)))
 	handleFunc("PUT /cart/byid/{id}", CartIdHandler(s.ProxyHandler(s.QuantityChangeHandler)))
-	handleFunc("POST /cart/byid/{id}/delivery", CartIdHandler(s.ProxyHandler(s.SetDeliveryHandler)))
-	handleFunc("DELETE /cart/byid/{id}/delivery/{deliveryId}", CartIdHandler(s.ProxyHandler(s.RemoveDeliveryHandler)))
-	handleFunc("PUT /cart/byid/{id}/delivery/{deliveryId}/pickupPoint", CartIdHandler(s.ProxyHandler(s.SetPickupPointHandler)))
 	handleFunc("PUT /cart/byid/{id}/voucher", CookieCartIdHandler(s.ProxyHandler(s.AddVoucherHandler)))
 	handleFunc("DELETE /cart/byid/{id}/voucher/{voucherId}", CookieCartIdHandler(s.ProxyHandler(s.RemoveVoucherHandler)))
 	handleFunc("PUT /cart/byid/{id}/user", CartIdHandler(s.ProxyHandler(s.SetUserIdHandler)))
 	handleFunc("PUT /cart/byid/{id}/item/{itemId}/marking", CartIdHandler(s.ProxyHandler(s.LineItemMarkingHandler)))
 	handleFunc("DELETE /cart/byid/{id}/item/{itemId}/marking", CartIdHandler(s.ProxyHandler(s.RemoveLineItemMarkingHandler)))
-
-	handleFunc("POST /cart/byid/{id}/checkout-order", CartIdHandler(s.ProxyHandler(s.CreateCheckoutOrderHandler)))
-	//mux.HandleFunc("GET /cart/byid/{id}/checkout", CartIdHandler(s.ProxyHandler(s.HandleCheckout)))
-	//mux.HandleFunc("GET /cart/byid/{id}/confirmation", CartIdHandler(s.ProxyHandler(s.HandleConfirmation)))
-
 }

cmd/cart/product-fetcher.go

@@ -7,7 +7,8 @@ import (
 	"net/http"
 
 	"git.k6n.net/go-cart-actor/pkg/cart"
-	messages "git.k6n.net/go-cart-actor/pkg/messages"
+	messages "git.k6n.net/go-cart-actor/proto/cart"
+
 	"github.com/matst80/slask-finder/pkg/index"
 )
 

cmd/cart/utils.go

@@ -0,0 +1,138 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"time"
+
+	"git.k6n.net/go-cart-actor/pkg/cart"
+	"github.com/matst80/go-redis-inventory/pkg/inventory"
+)
+
+func getCurrency(country string) string {
+	if country == "no" {
+		return "NOK"
+	}
+	return "SEK"
+}
+
+func getLocale(country string) string {
+	if country == "no" {
+		return "nb-no"
+	}
+	return "sv-se"
+}
+
+func getLocationId(item *cart.CartItem) inventory.LocationID {
+	if item.StoreId == nil || *item.StoreId == "" {
+		return "se"
+	}
+	return inventory.LocationID(*item.StoreId)
+}
+
+func getInventoryRequests(items []*cart.CartItem) []inventory.ReserveRequest {
+	var requests []inventory.ReserveRequest
+	for _, item := range items {
+		if item == nil {
+			continue
+		}
+		requests = append(requests, inventory.ReserveRequest{
+			InventoryReference: &inventory.InventoryReference{
+				SKU:        inventory.SKU(item.Sku),
+				LocationID: getLocationId(item),
+			},
+			Quantity: uint32(item.Quantity),
+		})
+	}
+	return requests
+}
+
+func getOriginalHost(r *http.Request) string {
+	proxyHost := r.Header.Get("X-Forwarded-Host")
+	if proxyHost != "" {
+		return proxyHost
+	}
+	return r.Host
+}
+
+func getClientIp(r *http.Request) string {
+	ip := r.Header.Get("X-Forwarded-For")
+	if ip == "" {
+		ip = r.RemoteAddr
+	}
+	return ip
+}
+
+func CookieCartIdHandler(fn func(cartId cart.CartId, w http.ResponseWriter, r *http.Request) error) func(w http.ResponseWriter, r *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		var id cart.CartId
+		cookie, err := r.Cookie("cartid")
+		if err != nil || cookie.Value == "" {
+			id = cart.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 := cart.ParseCartId(cookie.Value)
+			if !ok {
+				id = cart.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
+			}
+		}
+
+		err = fn(id, 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 CartIdHandler(fn func(cartId cart.CartId, w http.ResponseWriter, r *http.Request) error) func(w http.ResponseWriter, r *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var id cart.CartId
+		raw := r.PathValue("id")
+		// If no id supplied, generate a new one
+		if raw == "" {
+			id := cart.MustNewCartId()
+			w.Header().Set("Set-Cart-Id", id.String())
+		} else {
+			// Parse base62 cart id
+			if parsedId, ok := cart.ParseCartId(raw); !ok {
+				w.WriteHeader(http.StatusBadRequest)
+				w.Write([]byte("cart id is invalid"))
+				return
+			} else {
+				id = parsedId
+			}
+		}
+
+		err := fn(id, w, r)
+		if err != nil {
+			log.Printf("Server error, not remote error: %v\n", err)
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte(err.Error()))
+		}
+	}
+}