229 lines
7.2 KiB
Go
229 lines
7.2 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
|
|
"git.k6n.net/go-cart-actor/pkg/actor"
|
|
"git.k6n.net/go-cart-actor/pkg/cart"
|
|
"git.k6n.net/go-cart-actor/pkg/proxy"
|
|
messages "git.k6n.net/go-cart-actor/proto/checkout"
|
|
adyenCheckout "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"
|
|
)
|
|
|
|
type SessionRequest struct {
|
|
SessionId string `json:"sessionId"`
|
|
SessionResult string `json:"sessionResult"`
|
|
SessionData string `json:"sessionData,omitempty"`
|
|
}
|
|
|
|
func (s *CheckoutPoolServer) 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 getCheckoutIdFromNotificationItem(item webhook.NotificationRequestItem) (uint64, error) {
|
|
cartId, ok := cart.ParseCartId(item.MerchantReference)
|
|
if !ok {
|
|
return 0, errors.New("invalid cart id")
|
|
}
|
|
return uint64(cartId), nil
|
|
}
|
|
|
|
func (s *CheckoutPoolServer) AdyenHookHandler(w http.ResponseWriter, r *http.Request) {
|
|
var notificationRequest webhook.Webhook
|
|
service := s.adyenClient.Checkout()
|
|
if err := json.NewDecoder(r.Body).Decode(¬ificationRequest); 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, err := getCheckoutIdFromNotificationItem(item)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), 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(adyenCheckout.PaymentCaptureRequest{
|
|
Amount: adyenCheckout.Amount{
|
|
Currency: meta.Currency,
|
|
Value: grain.CartTotalPrice.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 *CheckoutPoolServer) 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(adyenCheckout.PaymentDetailsRequest{
|
|
Details: adyenCheckout.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)
|
|
}
|