mirror of
https://github.com/hanzoai/commerce.git
synced 2026-10-30 15:08:42 +00:00
zeekay
73b7290e7f
Square keeps an event's created_at across every retry, and the receiver refused anything older than five minutes, so every retry of an event first sent while cloud was down (Recreate, ten rollouts a day) was refused until Square gave up. The verifier now lives in payment/providers/square and needs only the key and the URL; thirdparty/square is the API client and no longer registers itself or verifies anything, so every registry holds one Square type. Replay is stopped by the event id instead: each verified event is recorded once for the whole deployment, keyed on the verifying processor and the event id with an insert-if-absent swap, so a repeat is a duplicate under any path or org. The path names the one processor that verifies, and only one that holds its webhook secret may: an unknown name, or a verifier that needs no secret, is refused rather than tried. The books an event lands in are the verifying account's, else the deployment's brand — never a header or session, which on a replay are the replayer's. An effect that did not land (a store or the ledger did not answer) leaves the delivery open with a 503, so the provider redelivers; it used to be acknowledged and never retried. A settlement reads the payment index before the org's books, because an in-session charge's receipt is in the payer's org. POST /v1/commerce/webhooks/:provider is declared once, in setupRoutes, so standalone and embedded commerce serve the same address; the /v1/billing/webhooks spelling is gone. thirdparty/kms read /v1/kms/orgs/<org>/secrets/..., which cloud no longer serves, and was off in production anyway, so per-org payment credentials never loaded. It is deleted. secrets.Org reads orgs/<org>/<name> through the host's reader, the caller re-pointed at that org with zip.ActingAs so the KMS tenancy check admits it, and payment.Hydrate loads an org's credentials where the org receives the money: storefront checkout, storefront subscriptions and wire, and the brand's bank for the billing wire rail. Hanzo's own billing no longer reads the paying org's credentials; it charges the deployment's account, as it did. The standalone binary reads through hanzoai/kms/sdk/go.
139 lines
3.6 KiB
Go
139 lines
3.6 KiB
Go
package subscription
|
|
|
|
import (
|
|
nethttp "net/http"
|
|
|
|
"github.com/zap-proto/zip"
|
|
|
|
"github.com/hanzoai/commerce/config"
|
|
"github.com/hanzoai/commerce/datastore"
|
|
"github.com/hanzoai/commerce/middleware"
|
|
"github.com/hanzoai/commerce/models/organization"
|
|
"github.com/hanzoai/commerce/models/subscription"
|
|
"github.com/hanzoai/commerce/payment"
|
|
"github.com/hanzoai/commerce/util/json/http"
|
|
"github.com/hanzoai/commerce/util/permission"
|
|
)
|
|
|
|
var subscriptionEndpoint = config.UrlFor("api", "/subscription/")
|
|
|
|
// hydrateOrg loads the org's own payment credentials: on this path the org is
|
|
// the merchant.
|
|
func hydrateOrg(c *zip.Ctx, org *organization.Organization) {
|
|
payment.Hydrate(c.Forward(), org) // Forward carries the caller the host's KMS admits
|
|
}
|
|
|
|
func getSubscription(c *zip.Ctx) (*subscription.Subscription, error) {
|
|
// Get organization for this user
|
|
org := middleware.GetOrganization(c)
|
|
|
|
// Set up the db with the namespaced context
|
|
ctx := org.Namespaced(c.Context())
|
|
db := datastore.New(ctx)
|
|
|
|
// Create order that's properly namespaced
|
|
sub := subscription.New(db)
|
|
|
|
// Get order if an existing order was referenced
|
|
if id := c.Param("subscriptionid"); id != "" {
|
|
if err := sub.GetById(id); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return sub, nil
|
|
}
|
|
|
|
func Subscribe(c *zip.Ctx) error {
|
|
org := middleware.GetOrganization(c)
|
|
hydrateOrg(c, org)
|
|
|
|
sub, _, err := subscribe(c, org)
|
|
if err != nil {
|
|
return http.Fail(c, 500, "Error during subscribe", err)
|
|
}
|
|
|
|
c.SetHeader("Location", subscriptionEndpoint+sub.Id())
|
|
num, err := sub.NumberFromId()
|
|
if err != nil {
|
|
return http.Fail(c, 500, "Error during subscribe", err)
|
|
}
|
|
sub.Number = num
|
|
|
|
return http.Render(c, 200, sub)
|
|
}
|
|
|
|
func GetSubscribe(c *zip.Ctx) error {
|
|
sub, err := getSubscription(c)
|
|
if err != nil {
|
|
return http.Fail(c, 404, "No subscription found", err)
|
|
}
|
|
|
|
num, err := sub.NumberFromId()
|
|
if err != nil {
|
|
return http.Fail(c, 500, "Error during subscribe", err)
|
|
}
|
|
sub.Number = num
|
|
return http.Render(c, 200, sub)
|
|
}
|
|
|
|
func UpdateSubscribe(c *zip.Ctx) error {
|
|
org := middleware.GetOrganization(c)
|
|
hydrateOrg(c, org)
|
|
sub, err := getSubscription(c)
|
|
if err != nil {
|
|
return http.Fail(c, 404, "No subscription found", err)
|
|
}
|
|
|
|
_, err = updateSubscribe(c, org, sub)
|
|
if err != nil {
|
|
return http.Fail(c, 500, "Error during subscribe", err)
|
|
}
|
|
|
|
num, err := sub.NumberFromId()
|
|
if err != nil {
|
|
return http.Fail(c, 500, "Error during subscribe", err)
|
|
}
|
|
sub.Number = num
|
|
|
|
return http.Render(c, 200, sub)
|
|
}
|
|
|
|
func Unsubscribe(c *zip.Ctx) error {
|
|
org := middleware.GetOrganization(c)
|
|
hydrateOrg(c, org)
|
|
sub, err := getSubscription(c)
|
|
if err != nil {
|
|
return http.Fail(c, 404, "No subscription found", err)
|
|
}
|
|
|
|
_, err = unsubscribe(c, org, sub)
|
|
if err != nil {
|
|
return http.Fail(c, 500, "Error during subscribe", err)
|
|
}
|
|
|
|
num, err := sub.NumberFromId()
|
|
if err != nil {
|
|
return http.Fail(c, 500, "Error during subscribe", err)
|
|
}
|
|
sub.Number = num
|
|
|
|
return http.Render(c, 200, sub)
|
|
}
|
|
|
|
func Route(router *zip.Group, args ...zip.Handler) {
|
|
api := router.Group("")
|
|
api.Use(zip.H(func(c *zip.Ctx) error {
|
|
c.SetHeader("Access-Control-Allow-Origin", "*")
|
|
return c.Next()
|
|
}))
|
|
|
|
publishedRequired := middleware.TokenRequired(permission.Admin, permission.Published)
|
|
|
|
// Charge Payment API
|
|
api.Raw(nethttp.MethodPost, "/subscribe", publishedRequired, Subscribe)
|
|
api.Raw(nethttp.MethodGet, "/subscribe/:subscriptionid", publishedRequired, GetSubscribe)
|
|
api.Raw(nethttp.MethodPatch, "/subscribe/:subscriptionid", publishedRequired, UpdateSubscribe)
|
|
api.Raw(nethttp.MethodDelete, "/subscribe/:subscriptionid", publishedRequired, Unsubscribe)
|
|
}
|