taler-merchant-demos

blog.go (10693B)

---

 package web
 
 import (
 	"errors"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"
 
 	"git.taler.net/taler-merchant-demos/internal/backend"
 )
 
 type blogIndexContent struct {
 	Articles []Article
 	BankURL  string
 	Price    string
 }
 
 type articleContent struct {
 	Article    Article
 	Refundable bool
 	RefundURL  string
 }
 
 type confirmRefundContent struct {
 	ArticleName string
 	OrderID     string
 }
 
 type refundedContent struct {
 	ArticleName string
 	OrderID     string
 }
 
 func (a *App) registerBlogRoutes() {
 	a.handleGet("/{lang}/{$}", a.blogIndex)
 	a.handleGet("/{lang}/essay/{article}", a.article)
 	a.handleGet("/{lang}/essay/{article}/data/{file}", a.articleData)
 	a.handleGet("/{lang}/confirm-refund/{order_id}", a.confirmRefund)
 	a.handlePost("/{lang}/refund/{order_id}", a.refund)
 }
 
 func (a *App) blogLanguage(w http.ResponseWriter, r *http.Request) (string, bool) {
 	lang := r.PathValue("lang")
 	if !validLocale(lang) {
 		a.renderError(w, r, http.StatusNotFound, "en", "Page not found", nil)
 		return "", false
 	}
 	return lang, true
 }
 
 func (a *App) blogIndex(w http.ResponseWriter, r *http.Request) {
 	lang, ok := a.blogLanguage(w, r)
 	if !ok {
 		return
 	}
 	articles := sortedArticles(a.articles[lang])
 	content := blogIndexContent{
 		Articles: articles,
 		BankURL:  configuredURL(a.opts.PublicURLs.Bank),
 		Price:    a.opts.Currency + ":" + articlePriceUnits,
 	}
 	a.render(w, "blog-index", a.makePage(r, lang, "GNU Taler Demo: Essay Shop", content), http.StatusOK)
 }
 
 func (a *App) article(w http.ResponseWriter, r *http.Request) {
 	lang, ok := a.blogLanguage(w, r)
 	if !ok {
 		return
 	}
 	articleName := r.PathValue("article")
 	article, exists := a.articles[lang][articleName]
 	if !exists {
 		a.renderError(w, r, http.StatusNotFound, lang, "Page not found", nil)
 		return
 	}
 	session := sessionID(r)
 	expectState := r.URL.Query().Get("expect_state") == "yes"
 	if session == "" {
 		if expectState {
 			a.renderError(w, r, http.StatusPreconditionFailed, lang, "Please enable cookies.", nil)
 			return
 		}
 		var err error
 		session, err = newSessionID()
 		if err != nil {
 			a.renderError(w, r, http.StatusInternalServerError, lang, "Could not create a browser session", err)
 			return
 		}
 		setSessionCookie(w, r, session)
 		target := queryRedirect(r, func(query url.Values) { query.Set("expect_state", "yes") })
 		http.Redirect(w, r, target, http.StatusFound)
 		return
 	}
 	if expectState {
 		target := queryRedirect(r, func(query url.Values) { query.Del("expect_state") })
 		http.Redirect(w, r, target, http.StatusFound)
 		return
 	}
 
 	articleURL := externalURL(r)
 	currentOrderID := orderID(r)
 	if currentOrderID != "" {
 		var current backend.OrderStatusResponse
 		err := a.opts.BlogBackend.Get(r.Context(), "private/orders/"+url.PathEscape(currentOrderID), url.Values{"session_id": {session}}, &current)
 		if err == nil {
 			if current.OrderStatus == "paid" && !current.Refunded {
 				if current.ContractTerms.Extra.ArticleName != articleName {
 					a.renderError(w, r, http.StatusPaymentRequired, lang, "The paid order does not match this article", nil)
 					return
 				}
 				_, canRefund := a.refundAmount(current)
 				a.renderArticle(w, r, lang, article, currentOrderID, canRefund)
 				return
 			}
 			if current.AlreadyPaidOrderID != "" {
 				setOrderCookie(w, r, lang, articleName, current.AlreadyPaidOrderID)
 				http.Redirect(w, r, forwardedPrefix(r)+r.URL.Path, http.StatusFound)
 				return
 			}
 			if current.Refunded && r.URL.Query().Get("new_if_refunded") != "yes" {
 				content := refundedContent{ArticleName: articleName, OrderID: currentOrderID}
 				a.render(w, "blog-refunded", a.makePage(r, lang, "GNU Taler Demo: Refunded", content), http.StatusOK)
 				return
 			}
 		} else if !backendStatus(err, http.StatusNotFound) {
 			a.renderError(w, r, http.StatusBadGateway, lang, "Backend request failed", err)
 			return
 		}
 	}
 
 	var history backend.OrderHistory
 	if err := a.opts.BlogBackend.Get(r.Context(), "private/orders", url.Values{
 		"session_id": {session}, "fulfillment_url": {articleURL}, "refunded": {"no"},
 	}, &history); err != nil {
 		a.renderError(w, r, http.StatusBadGateway, lang, "Backend request failed", err)
 		return
 	}
 	for _, previous := range history.Orders {
 		if previous.Paid && previous.OrderID != "" {
 			setOrderCookie(w, r, lang, articleName, previous.OrderID)
 			http.Redirect(w, r, forwardedPrefix(r)+r.URL.Path, http.StatusFound)
 			return
 		}
 	}
 
 	created, err := a.postArticleOrder(r, article, articleURL, session, lang)
 	if err != nil {
 		a.renderError(w, r, http.StatusBadGateway, lang, "Backend could not create the order", err)
 		return
 	}
 	if created.OrderID == "" || created.Token == "" {
 		a.renderError(w, r, http.StatusBadGateway, lang, "Backend response did not contain an order ID and token", nil)
 		return
 	}
 	paymentURL := a.opts.BlogBackend.URL("orders/"+url.PathEscape(created.OrderID), url.Values{"token": {created.Token}, "session_id": {session}})
 	setOrderCookie(w, r, lang, articleName, created.OrderID)
 	http.Redirect(w, r, paymentURL, http.StatusFound)
 }
 
 func (a *App) postArticleOrder(r *http.Request, article Article, articleURL, session, lang string) (backend.PostOrderResponse, error) {
 	now := time.Now()
 	choices := []backend.OrderChoice{{
 		// Translators: Merchant order description shown in the customer's wallet.
 		Amount: a.opts.Currency + ":" + articlePriceUnits, Description: a.catalogs.translate(lang, "Buy an individual article"),
 	}}
 	if a.opts.EnableTokens {
 		slug := subscriptionPrefix + lang
 		choices = append(choices,
 			backend.OrderChoice{
 				// Translators: Merchant order description shown in the customer's wallet.
 				Amount: a.opts.Currency + ":" + subscriptionUnits, Description: a.catalogs.translate(lang, "Buy one month of unlimited access"),
 				Outputs: []backend.OrderOutput{{Type: "token", TokenFamilySlug: slug}},
 			},
 			backend.OrderChoice{
 				Amount:  a.opts.Currency + ":0",
 				Inputs:  []backend.OrderInput{{Type: "token", TokenFamilySlug: slug}},
 				Outputs: []backend.OrderOutput{{Type: "token", TokenFamilySlug: slug}},
 			},
 		)
 	}
 	request := backend.PostOrderRequest{
 		Order: backend.Order{
 			Version:          1,
 			Extra:            backend.OrderExtra{ArticleName: article.Slug},
 			FulfillmentURL:   articleURL,
 			PublicReorderURL: articleURL,
 			// Translators: Merchant order summary shown in the wallet; {title} is the essay title.
 			Summary:              formatNamed(a.catalogs.translate(lang, "Essay: {title}"), "title", article.Title),
 			Choices:              choices,
 			PayDeadline:          backend.Timestamp{Seconds: now.Add(5 * time.Minute).Unix()},
 			WireTransferDeadline: backend.Timestamp{Seconds: now.Add(2 * time.Hour).Unix()},
 		},
 		SessionID:   session,
 		CreateToken: true,
 		RefundDelay: backend.RelativeTime{Microseconds: time.Hour.Microseconds()},
 	}
 	var response backend.PostOrderResponse
 	err := a.opts.BlogBackend.Post(r.Context(), "private/orders", request, &response)
 	return response, err
 }
 
 func (a *App) renderArticle(w http.ResponseWriter, r *http.Request, lang string, article Article, requestedOrderID string, canRefund bool) {
 	content := articleContent{
 		Article: article, Refundable: canRefund,
 		RefundURL: forwardedPrefix(r) + "/" + url.PathEscape(lang) + "/confirm-refund/" + url.PathEscape(requestedOrderID),
 	}
 	a.render(w, "blog-article", a.makePage(r, lang, "GNU Taler Demo: Article", content), http.StatusOK)
 }
 
 func (a *App) confirmRefund(w http.ResponseWriter, r *http.Request) {
 	lang, ok := a.blogLanguage(w, r)
 	if !ok {
 		return
 	}
 	requestedOrderID := r.PathValue("order_id")
 	var order backend.OrderStatusResponse
 	if err := a.opts.BlogBackend.Get(r.Context(), "private/orders/"+url.PathEscape(requestedOrderID), url.Values{"session_id": {sessionID(r)}}, &order); err != nil {
 		a.renderError(w, r, http.StatusBadGateway, lang, "Backend request failed", err)
 		return
 	}
 	if order.OrderStatus != "paid" {
 		a.renderError(w, r, http.StatusBadRequest, lang, "Cannot refund unpaid article", nil)
 		return
 	}
 	if _, ok := a.refundAmount(order); !ok {
 		a.renderError(w, r, http.StatusForbidden, lang, "This article can no longer be refunded.", nil)
 		return
 	}
 	content := confirmRefundContent{ArticleName: order.ContractTerms.Extra.ArticleName, OrderID: requestedOrderID}
 	a.render(w, "blog-confirm-refund", a.makePage(r, lang, "GNU Taler Demo: Confirm refund", content), http.StatusOK)
 }
 
 func (a *App) refund(w http.ResponseWriter, r *http.Request) {
 	lang, ok := a.blogLanguage(w, r)
 	if !ok {
 		return
 	}
 	requestedOrderID := r.PathValue("order_id")
 	if requestedOrderID == "" {
 		a.renderError(w, r, http.StatusBadRequest, lang, "Aborting refund: order unknown", nil)
 		return
 	}
 	var order backend.OrderStatusResponse
 	if err := a.opts.BlogBackend.Get(r.Context(), "private/orders/"+url.PathEscape(requestedOrderID), url.Values{"session_id": {sessionID(r)}}, &order); err != nil {
 		a.renderError(w, r, http.StatusBadGateway, lang, "Backend request failed", err)
 		return
 	}
 	if order.OrderStatus != "paid" {
 		a.renderError(w, r, http.StatusPaymentRequired, lang, "You did not pay for this article (nice try!)", nil)
 		return
 	}
 	amount, ok := a.refundAmount(order)
 	if !ok {
 		a.renderError(w, r, http.StatusForbidden, lang, "This article can no longer be refunded.", nil)
 		return
 	}
 	if err := a.opts.BlogBackend.Post(r.Context(), "private/orders/"+url.PathEscape(requestedOrderID)+"/refund", backend.RefundRequest{
 		// Translators: Refund reason shown in the customer's wallet.
 		Reason: a.catalogs.translate(lang, "Demo reimbursement"), Refund: amount,
 	}, nil); err != nil {
 		a.renderError(w, r, http.StatusBadGateway, lang, "Backend could not refund the order", err)
 		return
 	}
 	if order.OrderStatusURL == "" {
 		a.renderError(w, r, http.StatusBadGateway, lang, "Backend response did not contain an order status URL", nil)
 		return
 	}
 	http.Redirect(w, r, order.OrderStatusURL, http.StatusFound)
 }
 
 func backendStatus(err error, status int) bool {
 	var backendError *backend.Error
 	return errors.As(err, &backendError) && backendError.Status == status
 }
 
 func (a *App) refundAmount(order backend.OrderStatusResponse) (string, bool) {
 	if order.Refunded || order.ContractTerms.RefundDeadline.Seconds <= time.Now().Unix() {
 		return "", false
 	}
 	amount := order.ContractTerms.Amount
 	if order.ContractTerms.Version == 1 {
 		if order.ChoiceIndex == nil || *order.ChoiceIndex < 0 || *order.ChoiceIndex >= len(order.ContractTerms.Choices) {
 			return "", false
 		}
 		amount = order.ContractTerms.Choices[*order.ChoiceIndex].Amount
 	}
 	value, ok := strings.CutPrefix(amount, a.opts.Currency+":")
 	if !ok || value == "" || strings.Trim(value, "0.") == "" {
 		return "", false
 	}
 	return amount, true
 }