go-cart-actor/pool-server.go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strconv"
	"time"

	messages "git.tornberg.me/go-cart-actor/proto"
	"golang.org/x/exp/rand"
)

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) HandleGet(w http.ResponseWriter, r *http.Request, id CartId) error {
	data, err := s.pool.Get(id)
	if err != nil {
		return err
	}

	return s.WriteResult(w, data)
}

func (s *PoolServer) HandleAddSku(w http.ResponseWriter, r *http.Request, id CartId) error {
	sku := r.PathValue("sku")
	data, err := s.pool.Process(id, Message{
		Type:    AddRequestType,
		Content: &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 *FrameWithPayload) 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.StatusCode != 200 {
		log.Printf("Call error: %d\n", result.StatusCode)
		if result.StatusCode >= 200 && result.StatusCode < 600 {
			w.WriteHeader(int(result.StatusCode))
		} else {
			w.WriteHeader(http.StatusInternalServerError)
		}
		w.Write([]byte(result.Payload))
		return nil
	}
	w.WriteHeader(http.StatusOK)
	_, err := w.Write(result.Payload)
	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.pool.Process(id, Message{
		Type:    RemoveItemType,
		Content: &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"`
}

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.pool.Process(id, Message{
		Type: SetDeliveryType,
		Content: &messages.SetDelivery{
			Provider: delivery.Provider,
			Items:    delivery.Items,
		},
	})
	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.pool.Process(id, Message{
		Type: SetPickupPointType,
		Content: &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.pool.Process(id, Message{
		Type:    RemoveDeliveryType,
		Content: &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.pool.Process(id, Message{
		Type:    ChangeQuantityType,
		Content: &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.pool.Process(id, Message{
		Type:    SetCartItemsType,
		Content: &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.pool.Process(id, Message{
		Type:    AddRequestType,
		Content: &addRequest,
	})
	if err != nil {
		return err
	}
	return s.WriteResult(w, reply)
}

var (
	APIUsername = os.Getenv("KLARNA_API_USERNAME")
	APIPassword = os.Getenv("KLARNA_API_PASSWORD")
)

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")
	}
	req, err := http.NewRequest("GET", fmt.Sprintf("https://api.playground.klarna.com/checkout/v3/orders/%s", orderId), nil)
	if err != nil {
		return err
	}

	req.Header.Add("Content-Type", "application/json")
	req.SetBasicAuth(APIUsername, APIPassword)

	res, err := http.DefaultClient.Do(req)
	if nil != err {
		return err
	}
	buf := new(bytes.Buffer)
	buf.ReadFrom(res.Body)
	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(res.StatusCode)

	w.Write(buf.Bytes())
	return nil
}

func (s *PoolServer) HandleCheckout(w http.ResponseWriter, r *http.Request, id CartId) error {

	reply, err := s.pool.Process(id, Message{
		Type: CreateCheckoutOrderType,
		Content: &messages.CreateCheckoutOrder{
			Terms:        "https://slask-finder.tornberg.me/terms",
			Checkout:     "https://slask-finder.tornberg.me/checkout?order_id={checkout.order.id}",
			Confirmation: "https://slask-finder.tornberg.me/confirmation/{checkout.order.id}",
			Push:         "https://cart.tornberg.me/push?order_id={checkout.order.id}",
		},
	})
	if err != nil {
		return err
	}
	if reply.StatusCode != 200 {
		return s.WriteResult(w, reply)
	}

	req, err := http.NewRequest("POST", "https://api.playground.klarna.com/checkout/v3/orders", bytes.NewReader(reply.Payload))
	if err != nil {
		return err
	}

	req.Header.Add("Content-Type", "application/json")
	req.SetBasicAuth(APIUsername, APIPassword)

	res, err := http.DefaultClient.Do(req)
	if nil != err {
		return err
	}

	buf := new(bytes.Buffer)
	buf.ReadFrom(res.Body)
	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(res.StatusCode)

	w.Write(buf.Bytes())
	return nil
}

func NewCartId() CartId {
	id := time.Now().UnixNano() + rand.Int63()

	return ToCartId(fmt.Sprintf("%d", id))
}

func CookieCartIdHandler(fn func(w http.ResponseWriter, r *http.Request, cartId CartId) error) func(w http.ResponseWriter, r *http.Request) error {
	return func(w http.ResponseWriter, r *http.Request) error {
		var cartId CartId
		cartIdCookie := r.CookiesNamed("cartid")
		if cartIdCookie == nil || len(cartIdCookie) == 0 {
			cartId = NewCartId()
			http.SetCookie(w, &http.Cookie{
				Name:     "cartid",
				Value:    cartId.String(),
				Path:     "/",
				SameSite: http.SameSiteLaxMode,
			})
		} else {
			cartId = ToCartId(cartIdCookie[0].Value)
		}
		return fn(w, r, cartId)
	}
}

func (s *PoolServer) RemoveCartCookie(w http.ResponseWriter, r *http.Request, cartId CartId) error {
	cartId = NewCartId()
	http.SetCookie(w, &http.Cookie{
		Name:     "cartid",
		Value:    cartId.String(),
		Path:     "/",
		SameSite: http.SameSiteLaxMode,
	})
	w.WriteHeader(http.StatusOK)
	return nil
}

func CartIdHandler(fn func(w http.ResponseWriter, r *http.Request, cartId CartId) error) func(w http.ResponseWriter, r *http.Request) error {
	return func(w http.ResponseWriter, r *http.Request) error {
		cartId := ToCartId(r.PathValue("id"))
		return fn(w, r, cartId)
	}
}

func (s *PoolServer) Serve() *http.ServeMux {
	mux := http.NewServeMux()
	//mux.HandleFunc("/", s.RewritePath)
	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.HandleGet)))
	mux.HandleFunc("GET /add/{sku}", ErrorHandler(CookieCartIdHandler(s.HandleAddSku)))
	mux.HandleFunc("POST /", ErrorHandler(CookieCartIdHandler(s.HandleAddRequest)))
	mux.HandleFunc("POST /set", ErrorHandler(CookieCartIdHandler(s.HandleSetCartItems)))
	mux.HandleFunc("DELETE /{itemId}", ErrorHandler(CookieCartIdHandler(s.HandleDeleteItem)))
	mux.HandleFunc("PUT /", ErrorHandler(CookieCartIdHandler(s.HandleQuantityChange)))
	mux.HandleFunc("DELETE /", ErrorHandler(CookieCartIdHandler(s.RemoveCartCookie)))
	mux.HandleFunc("POST /delivery", ErrorHandler(CookieCartIdHandler(s.HandleSetDelivery)))
	mux.HandleFunc("DELETE /delivery/{deliveryId}", ErrorHandler(CookieCartIdHandler(s.HandleRemoveDelivery)))
	mux.HandleFunc("PUT /delivery/{deliveryId}/pickupPoint", ErrorHandler(CookieCartIdHandler(s.HandleSetPickupPoint)))
	mux.HandleFunc("GET /checkout", ErrorHandler(CookieCartIdHandler(s.HandleCheckout)))
	mux.HandleFunc("GET /confirmation/{orderId}", ErrorHandler(CookieCartIdHandler(s.HandleConfirmation)))

	mux.HandleFunc("GET /byid/{id}", ErrorHandler(CartIdHandler(s.HandleGet)))
	mux.HandleFunc("GET /byid/{id}/add/{sku}", ErrorHandler(CartIdHandler(s.HandleAddSku)))
	mux.HandleFunc("POST /byid/{id}", ErrorHandler(CartIdHandler(s.HandleAddRequest)))
	mux.HandleFunc("DELETE /byid/{id}/{itemId}", ErrorHandler(CartIdHandler(s.HandleDeleteItem)))
	mux.HandleFunc("PUT /byid/{id}", ErrorHandler(CartIdHandler(s.HandleQuantityChange)))
	mux.HandleFunc("POST /byid/{id}/delivery", ErrorHandler(CartIdHandler(s.HandleSetDelivery)))
	mux.HandleFunc("DELETE /byid/{id}/delivery/{deliveryId}", ErrorHandler(CartIdHandler(s.HandleRemoveDelivery)))
	mux.HandleFunc("PUT /byid/{id}/delivery/{deliveryId}/pickupPoint", ErrorHandler(CartIdHandler(s.HandleSetPickupPoint)))
	mux.HandleFunc("GET /byid/{id}/checkout", ErrorHandler(CartIdHandler(s.HandleCheckout)))
	mux.HandleFunc("GET /byid/{id}/confirmation", ErrorHandler(CartIdHandler(s.HandleConfirmation)))

	return mux
}