rimgo/pages/rss.go

package pages

import (
	"mime"
	"net/http"
	"time"

	"codeberg.org/rimgo/rimgo/api"
	"codeberg.org/rimgo/rimgo/utils"
	"github.com/gorilla/feeds"
)

func HandleTagRSS(w http.ResponseWriter, r *http.Request) error {
	utils.SetHeaders(w)

	tag, err := ApiClient.FetchTag(r.PathValue("tag"), r.URL.Query().Get("sort"), "1")
	if err != nil && err.Error() == "ratelimited by imgur" {
		w.WriteHeader(429)
		_, err := w.Write([]byte("rate limited by imgur"))
		return err
	}
	if err != nil {
		return err
	}
	if tag.Display == "" {
		w.WriteHeader(404)
		_, err := w.Write([]byte("tag not found"))
		return err
	}

	instance := utils.GetInstanceUrl(r)

	feed := &feeds.Feed{
		Title:   tag.Display + " on Imgur",
		Link:    &feeds.Link{Href: instance + "/t/" + r.PathValue("tag")},
		Created: time.Now(),
	}

	return handleFeed(w, r, instance, feed, tag.Posts)
}

func HandleTrendingRSS(w http.ResponseWriter, r *http.Request) error {
	utils.SetHeaders(w)

	section := r.URL.Query().Get("section")
	switch section {
	case "hot", "new", "top":
	default:
		section = "hot"
	}
	sort := r.URL.Query().Get("sort")
	switch sort {
	case "newest", "best", "popular":
	default:
		sort = "popular"
	}

	results, err := ApiClient.FetchTrending(section, sort, "1")
	if err != nil {
		return err
	}

	instance := utils.GetInstanceUrl(r)

	feed := &feeds.Feed{
		Title:   "Trending on Imgur",
		Link:    &feeds.Link{Href: instance + "/trending"},
		Created: time.Now(),
	}

	return handleFeed(w, r, instance, feed, results)
}

func HandleUserRSS(w http.ResponseWriter, r *http.Request) error {
	utils.SetHeaders(w)

	user := r.PathValue("userID")

	submissions, err := ApiClient.FetchSubmissions(user, "newest", "1")
	if err != nil && err.Error() == "ratelimited by imgur" {
		return RenderError(w, r, 429)
	}
	if err != nil {
		return err
	}

	instance := utils.GetInstanceUrl(r)

	feed := &feeds.Feed{
		Title:   user + " on Imgur",
		Link:    &feeds.Link{Href: instance + "/user/" + user},
		Created: time.Now(),
	}

	return handleFeed(w, r, instance, feed, submissions)
}

func handleFeed(w http.ResponseWriter, r *http.Request, instance string, feed *feeds.Feed, posts []api.Submission) error {
	feed.Items = []*feeds.Item{}

	for _, post := range posts {
		link := instance + post.Link

		item := &feeds.Item{
			Title:       post.Title,
			Link:        &feeds.Link{Href: link},
			Description: "<a href=\"" + link + "\"><img width=\"480\" src=\"" + instance + "/" + post.Cover.Id + ".jpeg" + "\"></a>",
		}

		if post.Cover.Type == "video" {
			item.Description = "🎞️ Video<br><br>" + item.Description
		}

		feed.Items = append(feed.Items, item)
	}

	w.Header().Set("Content-Type", mime.TypeByExtension("."+r.PathValue("type")))
	switch r.PathValue("type") {
	case "atom":
		body, err := feed.ToAtom()
		if err != nil {
			return err
		}
		w.Write([]byte(body))
	case "json":
		body, err := feed.ToJSON()
		if err != nil {
			return err
		}
		w.Write([]byte(body))
	case "rss":
		body, err := feed.ToRss()
		if err != nil {
			return err
		}
		w.Write([]byte(body))
	default:
		w.Header().Set("Content-Type", "text/plain")
		w.WriteHeader(400)
		w.Write([]byte("invalid type"))
	}
	return nil
}