added initial webhook main function

example.go

@@ -7,10 +7,6 @@ import (
 	"github.com/debyltech/go-snipcart/snipcart"
 )
 
-const (
-	configFile = "config.json"
-)
-
 func main() {
 	snipcartApiKey := flag.String("key", "", "Snipcart API Key")
 	flag.Parse()
@@ -19,9 +15,9 @@ func main() {
 		log.Fatal("missing -key flag")
 	}
 
-	snipcartProvider := snipcart.NewSnipcartProvider(*snipcartApiKey)
+	Client := snipcart.NewClient(*snipcartApiKey)
 
-	response, err := snipcartProvider.GetOrdersByStatus(snipcart.Processed)
+	response, err := Client.GetOrdersByStatus(snipcart.Processed)
 	if err != nil {
 		log.Fatal(err)
 	}

example_get_order.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+
+	"github.com/debyltech/go-snipcart/snipcart"
+)
+
+func main() {
+	snipcartApiKey := flag.String("key", "", "Snipcart API Key")
+	flag.Parse()
+
+	if *snipcartApiKey == "" {
+		log.Fatal("missing -key flag")
+	}
+
+	Client := snipcart.NewClient(*snipcartApiKey)
+
+	response, err := Client.GetOrder("b35990df-c0ca-4014-94de-1caa7bd7bb51")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	byteResponse, err := json.Marshal(response)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Println(string(byteResponse))
+}

example_update_order.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"flag"
+	"log"
+
+	"github.com/debyltech/go-snipcart/snipcart"
+)
+
+func main() {
+	snipcartApiKey := flag.String("key", "", "Snipcart API Key")
+	flag.Parse()
+
+	if *snipcartApiKey == "" {
+		log.Fatal("missing -key flag")
+	}
+
+	Client := snipcart.NewClient(*snipcartApiKey)
+
+	updateOrder := snipcart.SnipcartOrderUpdate{
+		Status: snipcart.Delivered,
+	}
+
+	response, err := Client.UpdateOrder("b35990df-c0ca-4014-94de-1caa7bd7bb51", &updateOrder)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for k, v := range response.Items {
+		log.Printf("%v: %v\n", k, v)
+	}
+}

go.mod

@@ -2,4 +2,35 @@ module github.com/debyltech/go-snipcart
 
 go 1.20
 
-require github.com/debyltech/go-helpers v0.0.0-20230224002154-eb55816c71ec
+require (
+	github.com/debyltech/go-helpers v1.1.0
+	github.com/debyltech/go-shippr v0.1.0
+	github.com/gin-gonic/gin v1.9.0
+	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
+)
+
+require (
+	github.com/bytedance/sonic v1.8.0 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.11.2 // indirect
+	github.com/goccy/go-json v0.10.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
+	github.com/leodido/go-urn v1.2.1 // indirect
+	github.com/mattn/go-isatty v0.0.17 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.6 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.9 // indirect
+	golang.org/x/arch v0.0.0-20210923205945-b76863e36670 // indirect
+	golang.org/x/crypto v0.5.0 // indirect
+	golang.org/x/net v0.7.0 // indirect
+	golang.org/x/sys v0.5.0 // indirect
+	golang.org/x/text v0.7.0 // indirect
+	google.golang.org/protobuf v1.28.1 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

snipcart/snipcart.go

@@ -6,7 +6,8 @@ import (
 	"errors"
 	"fmt"
 
-	helper "github.com/debyltech/go-helpers"
+	helper "github.com/debyltech/go-helpers/json"
+	"github.com/skip2/go-qrcode"
 )
 
 const (
@@ -19,59 +20,102 @@ var (
 	orderUri = apiUri + ordersPath
 )
 
-type SnipcartProvider struct {
+type Client struct {
 	SnipcartKey string
 	AuthBase64  string
 	Limit       int
 }
 
+type SnipcartCustomField struct {
+	Name  string `json:"name"`
+	Value string `json:"value"`
+}
+
 type SnipcartItem struct {
-	UUID             string  `json:"uniqueId"`
+	UUID         string                `json:"uniqueId"`
-	ID               string  `json:"id"`
+	ID           string                `json:"id"`
-	Name             string  `json:"name"`
+	Name         string                `json:"name"`
-	Quantity         float64 `json:"quantity"`
+	Quantity     int                   `json:"quantity"`
-	Weight           string  `json:"weight"`
+	TotalWeight  float64               `json:"totalWeight,omitempty"`
-	TotalWeight      float64 `json:"totalWeight"`
+	TotalPrice   float64               `json:"totalPrice,omitempty"`
-	CustomFieldsJSON string  `json:"customFieldsJson"`
+	CustomFields []SnipcartCustomField `json:"customFields"`
+	Length       float64               `json:"length,omitempty"`
+	Width        float64               `json:"width,omitempty"`
+	Height       float64               `json:"height,omitempty"`
+	Weight       float64               `json:"weight,omitempty"`
+	Shippable    bool                  `json:"shippable,omitempty"`
 }
 
 type SnipcartOrder struct {
 	Token          string         `json:"token"`
 	Invoice        string         `json:"invoiceNumber"`
+	Subtotal       float64        `json:"subtotal,omitempty"`
+	Currency       string         `json:"currency,omitempty"`
+	Total          float64        `json:"grandTotal,omitempty"`
 	Status         string         `json:"status"`
 	TotalWeight    float64        `json:"totalWeight"`
-	Email          string         `json:"email"`
 	Name           string         `json:"shippingAddressName"`
+	Company        string         `json:"shippingAddressCompanyName"`
 	Address1       string         `json:"shippingAddressAddress1"`
 	Address2       string         `json:"shippingAddressAddress2"`
 	City           string         `json:"shippingAddressCity"`
 	Province       string         `json:"shippingAddressProvince"`
 	Country        string         `json:"shippingAddressCountry"`
 	PostalCode     string         `json:"shippingAddressPostalCode"`
-	Phone          string         `json:"shippingAddressPhone"`
+	Phone          string         `json:"shippingAddressPhone,omitempty"`
+	Email          string         `json:"email,omitempty"`
 	TrackingNumber string         `json:"trackingNumber"`
 	TrackingUrl    string         `json:"trackingUrl"`
+	ShippingCost   float64        `json:"shippingFees"`
 	Items          []SnipcartItem `json:"items"`
 }
 
+type SnipcartOrderUpdate struct {
+	Status         OrderStatus `json:"status"`
+	PaymentStatus  string      `json:"paymentStatus,omitempty"`
+	TrackingNumber string      `json:"trackingNumber,omitempty"`
+	TrackingUrl    string      `json:"trackingUrl,omitempty"`
+	Metadata       any         `json:"metadata,omitempty"`
+}
+
 type SnipcartOrders struct {
 	TotalItems int
 	Items      []SnipcartOrder
 }
 
-func NewSnipcartProvider(snipcartApiKey string) SnipcartProvider {
+func NewClient(snipcartApiKey string) Client {
-	return SnipcartProvider{
+	return Client{
 		SnipcartKey: snipcartApiKey,
 		AuthBase64:  base64.StdEncoding.EncodeToString([]byte(snipcartApiKey + ":")),
 	}
 }
 
-func (s *SnipcartProvider) GetOrders(queries map[string]string) (*SnipcartOrders, error) {
+func (s *Client) GetOrder(token string) (*SnipcartOrder, error) {
+	response, err := helper.Get(orderUri+"/"+token, "Basic", s.AuthBase64, nil)
+	if err != nil {
+		return nil, err
+	}
+	if response.StatusCode < 200 && response.StatusCode >= 300 {
+		return nil, fmt.Errorf("unexpected response received: %s", response.Status)
+	}
+
+	defer response.Body.Close()
+
+	var order SnipcartOrder
+	err = json.NewDecoder(response.Body).Decode(&order)
+	if err != nil {
+		return nil, err
+	}
+
+	return &order, nil
+}
+
+func (s *Client) GetOrders(queries map[string]string) (*SnipcartOrders, error) {
 	response, err := helper.Get(orderUri, "Basic", s.AuthBase64, queries)
 	if err != nil {
 		return nil, err
 	}
-	if response.Status != "200 OK" {
+	if response.StatusCode < 200 && response.StatusCode >= 300 {
 		return nil, fmt.Errorf("unexpected response received: %s", response.Status)
 	}
 
@@ -86,10 +130,40 @@ func (s *SnipcartProvider) GetOrders(queries map[string]string) (*SnipcartOrders
 	return &orders, nil
 }
 
-func (s *SnipcartProvider) GetOrdersByStatus(status OrderStatus) (*SnipcartOrders, error) {
+func (s *Client) GetOrdersByStatus(status OrderStatus) (*SnipcartOrders, error) {
 	if status == "" {
 		return nil, errors.New("status is not set")
 	}
 
 	return s.GetOrders(map[string]string{"status": string(status)})
 }
+
+func (o *SnipcartOrder) TokenPNGBase64() (string, error) {
+	img, err := qrcode.Encode("order:"+o.Token, qrcode.Medium, 128)
+	if err != nil {
+		return "", err
+	}
+
+	return base64.StdEncoding.EncodeToString(img), nil
+}
+
+func (s *Client) UpdateOrder(token string, orderUpdate *SnipcartOrderUpdate) (*SnipcartOrder, error) {
+	response, err := helper.Put(orderUri+"/"+token, "Basic", s.AuthBase64, orderUpdate)
+	if err != nil {
+		return nil, err
+	}
+	if response.StatusCode < 200 && response.StatusCode >= 300 {
+		return nil, fmt.Errorf("unexpected response received: %s", response.Status)
+	}
+	fmt.Println(response.Status)
+
+	defer response.Body.Close()
+
+	var responseOrder SnipcartOrder
+	err = json.NewDecoder(response.Body).Decode(&responseOrder)
+	if err != nil {
+		return nil, err
+	}
+
+	return &responseOrder, nil
+}

snipcart/webhook/config.go

@@ -0,0 +1,33 @@
+package webhook
+
+import (
+	"bytes"
+	"encoding/json"
+	"io/ioutil"
+
+	"github.com/debyltech/go-shippr/shippo"
+)
+
+type Config struct {
+	ShippoApiKey       string         `json:"shippo_api_key"`
+	WeightUnit         string         `json:"weight_unit"`
+	DimensionUnit      string         `json:"dimension_unit"`
+	ManufactureCountry string         `json:"manufacture_country"`
+	SenderAddress      shippo.Address `json:"sender_address"`
+	DefaultParcel      shippo.Parcel  `json:"default_parcel"`
+}
+
+func NewConfigFromFile(filePath string) (*Config, error) {
+	configBytes, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return nil, err
+	}
+
+	var config Config
+	err = json.NewDecoder(bytes.NewBuffer(configBytes)).Decode(&config)
+	if err != nil {
+		return nil, err
+	}
+
+	return &config, nil
+}

webhook.go

@@ -0,0 +1,162 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/debyltech/go-shippr/shippo"
+	"github.com/debyltech/go-snipcart/snipcart"
+	"github.com/debyltech/go-snipcart/snipcart/webhook"
+	"github.com/gin-gonic/gin"
+)
+
+const (
+	ValidateUrl string = "https://app.snipcart.com/api/requestvalidation/"
+)
+
+type ShippingWebhookEvent struct {
+	EventName string                 `json:"eventName"`
+	CreatedOn time.Time              `json:"createdOn"`
+	Order     snipcart.SnipcartOrder `json:"content"`
+}
+
+type ShippingRatesResponse struct {
+	Cost         float64 `json:"cost"`
+	Description  string  `json:"description"`
+	DeliveryDays int     `json:"guaranteedDaysToDelivery"`
+}
+
+func ValidateWebhook(token string) error {
+	validateRequest, err := http.Get(ValidateUrl + token)
+	if err != nil {
+		return err
+	}
+
+	if validateRequest.StatusCode < 200 || validateRequest.StatusCode >= 300 {
+		return errors.New("non-2XX response received")
+	}
+
+	return nil
+}
+
+func HandleShippingRates(config *webhook.Config, shippoClient *shippo.Client) gin.HandlerFunc {
+	fn := func(c *gin.Context) {
+		err := ValidateWebhook(c.GetHeader("X-Snipcart-RequestToken"))
+		if err != nil {
+			c.AbortWithError(http.StatusBadRequest, err)
+			return
+		}
+
+		var event ShippingWebhookEvent
+		err = json.NewDecoder(c.Request.Body).Decode(&event)
+		if err != nil {
+			c.AbortWithError(http.StatusInternalServerError, err)
+			return
+		}
+
+		defer c.Request.Body.Close()
+
+		var lineItems []shippo.LineItem
+		for _, v := range event.Order.Items {
+			lineItems = append(lineItems, shippo.LineItem{
+				Quantity:           v.Quantity,
+				TotalPrice:         fmt.Sprintf("%.2f", v.TotalPrice),
+				Currency:           event.Order.Currency,
+				Weight:             fmt.Sprintf("%.2f", v.Weight),
+				WeightUnit:         config.WeightUnit,
+				Title:              v.Name,
+				ManufactureCountry: config.ManufactureCountry,
+				Sku:                v.ID,
+			})
+		}
+
+		parcel := config.DefaultParcel
+		parcel.WeightUnit = config.WeightUnit
+		parcel.DistanceUnit = config.DimensionUnit
+		parcel.Weight = fmt.Sprintf("%.2f", event.Order.TotalWeight)
+
+		rateRequest := shippo.RateRequest{
+			AddressFrom: shippo.Address{
+				Name:       config.SenderAddress.Name,
+				Address1:   config.SenderAddress.Address1,
+				Address2:   config.SenderAddress.Address2,
+				City:       config.SenderAddress.City,
+				State:      config.SenderAddress.State,
+				Country:    config.SenderAddress.Country,
+				PostalCode: config.SenderAddress.PostalCode,
+			},
+			AddressTo: shippo.Address{
+				Name:       event.Order.Name,
+				Company:    event.Order.Company,
+				Address1:   event.Order.Address1,
+				Address2:   event.Order.Address2,
+				City:       event.Order.City,
+				Country:    event.Order.Country,
+				State:      event.Order.Province,
+				PostalCode: event.Order.PostalCode,
+				Phone:      event.Order.Phone,
+				Email:      event.Order.Email,
+			},
+			LineItems: lineItems,
+			Parcel:    parcel,
+		}
+
+		rateResponse, err := shippoClient.GenerateRates(rateRequest)
+		if err != nil {
+			c.AbortWithError(http.StatusBadRequest, err)
+			return
+		}
+
+		var rates []ShippingRatesResponse
+		for _, v := range rateResponse.Rates {
+			cost, err := strconv.ParseFloat(v.Amount, 64)
+			if err != nil {
+				c.AbortWithError(http.StatusInternalServerError, err)
+				return
+			}
+			rates = append(rates, ShippingRatesResponse{
+				Cost:         cost,
+				Description:  v.Title,
+				DeliveryDays: v.EstimatedDays,
+			})
+		}
+
+		c.JSON(http.StatusOK, rates)
+	}
+
+	return fn
+}
+
+func main() {
+	configPath := flag.String("config", "", "path to config.json")
+	flag.Parse()
+
+	if *configPath == "" {
+		log.Fatal("config path not defined")
+	}
+
+	config, err := webhook.NewConfigFromFile(*configPath)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	shippoClient := shippo.NewClient(config.ShippoApiKey)
+
+	r := gin.Default()
+
+	api := r.Group("/api")
+	{
+		v1 := api.Group("/v1")
+		{
+			v1.POST("/shipping", HandleShippingRates(config, &shippoClient))
+		}
+	}
+
+	r.Run("localhost:8081")
+}