package display import ( "fmt" "net/url" "path" "sort" "strconv" "strings" "time" "github.com/gdamore/tcell/v2" "github.com/makeworld-the-better-one/amfora/cache" "github.com/makeworld-the-better-one/amfora/config" "github.com/makeworld-the-better-one/amfora/renderer" "github.com/makeworld-the-better-one/amfora/structs" "github.com/makeworld-the-better-one/amfora/subscriptions" "github.com/makeworld-the-better-one/go-gemini" "github.com/mmcdole/gofeed" "github.com/spf13/viper" ) // Map page number (zero-indexed) to the time it was made at. // This allows for caching the pages until there's an update. var subscriptionPageUpdated = make(map[int]time.Time) // toLocalDay truncates the provided time to a date only, // but converts to the local time first. func toLocalDay(t time.Time) time.Time { t = t.Local() return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location()) } // Subscriptions displays the subscriptions page on the current tab. func Subscriptions(t *tab, u string) string { pageN := 0 // Pages are zero-indexed internally // Correct URL if query string exists // The only valid query string is an int above 1. // Anything "redirects" to the first page, with no query string. // This is done over just serving the first page content for // invalid query strings so that there won't be duplicate caches. correctURL := func(u2 string) string { if len(u2) > 20 && u2[:20] == "about:subscriptions?" { query, err := gemini.QueryUnescape(u2[20:]) if err != nil { return "about:subscriptions" } // Valid query string i, err := strconv.Atoi(query) if err != nil { // Not an int return "about:subscriptions" } if i < 2 { return "about:subscriptions" } // Valid int above 1 pageN = i - 1 // Pages are zero-indexed internally return u2 } return u2 } u = correctURL(u) // Retrieve cached version if there hasn't been any updates p, ok := cache.GetPage(u) if subscriptionPageUpdated[pageN].After(subscriptions.LastUpdated) && ok { setPage(t, p) t.applyBottomBar() return u } pe := subscriptions.GetPageEntries() // Figure out where the entries for this page start, if at all. epp := viper.GetInt("subscriptions.entries_per_page") if epp <= 0 { epp = 1 } start := pageN * epp // Index of the first page entry to be displayed end := start + epp if end > len(pe.Entries) { end = len(pe.Entries) } var rawPage string if pageN == 0 { rawPage = "# Subscriptions\n\n" + rawPage } else { rawPage = fmt.Sprintf("# Subscriptions (page %d)\n\n", pageN+1) + rawPage } if start > len(pe.Entries)-1 && len(pe.Entries) != 0 { // The page is out of range, doesn't exist rawPage += "This page does not exist.\n\n=> about:subscriptions Subscriptions\n" } else { // Render page if viper.GetBool("subscriptions.header") { rawPage += "You can use Ctrl-X to subscribe to a page, or to an Atom/RSS/JSON feed." + "See the online wiki for more.\n" + "If you just opened Amfora then updates may appear incrementally. Reload the page to see them.\n\n" } rawPage += "=> about:manage-subscriptions Manage subscriptions\n\n" // curDay represents what day of posts the loop is on. // It only goes backwards in time. // Its initial setting means: // Only display posts older than 26 hours in the future, nothing further in the future. // // 26 hours was chosen because it is the largest timezone difference // currently in the world. Posts may be dated in the future // due to software bugs, where the local user's date is used, but // the UTC timezone is specified. Gemfeed does this at the time of // writing, but will not after #3 gets merged on its repo. Still, // the older version will be used for a while. curDay := toLocalDay(time.Now()).Add(26 * time.Hour) for _, entry := range pe.Entries[start:end] { // From new to old // Convert to local time, remove sub-day info pub := toLocalDay(entry.Published) if pub.Before(curDay) { // This post is on a new day, add a day header curDay = pub rawPage += fmt.Sprintf("\n## %s\n\n", curDay.Format("Jan 02, 2006")) } if entry.Title == "" || entry.Title == "/" { // Just put author/title // Mainly used for when you're tracking the root domain of a site rawPage += fmt.Sprintf("=>%s %s\n", entry.URL, entry.Prefix) } else { // Include title and dash rawPage += fmt.Sprintf("=>%s %s - %s\n", entry.URL, entry.Prefix, entry.Title) } } if pageN == 0 && len(pe.Entries) > epp { // First page, and there's more than can fit rawPage += "\n\n=> about:subscriptions?2 Next Page\n" } else if pageN > 0 { // A later page rawPage += fmt.Sprintf( "\n\n=> about:subscriptions?%d Previous Page\n", pageN, // pageN is zero-indexed but the query string is one-indexed ) if end != len(pe.Entries) { // There's more rawPage += fmt.Sprintf("=> about:subscriptions?%d Next Page\n", pageN+2) } } } content, links := renderer.RenderGemini(rawPage, textWidth(), false) page := structs.Page{ Raw: rawPage, Content: content, Links: links, URL: u, TermWidth: termW, Mediatype: structs.TextGemini, } go cache.AddPage(&page) setPage(t, &page) t.applyBottomBar() subscriptionPageUpdated[pageN] = time.Now() return u } // ManageSubscriptions displays the subscription managing page in // the current tab. `u` is the URL entered by the user. func ManageSubscriptions(t *tab, u string) { if len(u) > 27 && u[:27] == "about:manage-subscriptions?" { // There's a query string, aka a URL to unsubscribe from manageSubscriptionQuery(t, u) return } rawPage := "# Manage Subscriptions\n\n" + "Below is list of URLs you are subscribed to, both feeds and pages. " + "Navigate to the link to unsubscribe from that feed or page.\n\n" urls := subscriptions.AllURLS() sort.Strings(urls) for _, u2 := range urls { rawPage += fmt.Sprintf( "=>%s %s\n", "about:manage-subscriptions?"+gemini.QueryEscape(u2), u2, ) } content, links := renderer.RenderGemini(rawPage, textWidth(), false) page := structs.Page{ Raw: rawPage, Content: content, Links: links, URL: "about:manage-subscriptions", TermWidth: termW, Mediatype: structs.TextGemini, } go cache.AddPage(&page) setPage(t, &page) t.applyBottomBar() } func manageSubscriptionQuery(t *tab, u string) { sub, err := gemini.QueryUnescape(u[27:]) if err != nil { Error("URL Error", "Invalid query string: "+err.Error()) return } err = subscriptions.Remove(sub) if err != nil { ManageSubscriptions(t, "about:manage-subscriptions") // Reload Error("Save Error", "Error saving the unsubscription to disk: "+err.Error()) return } ManageSubscriptions(t, "about:manage-subscriptions") // Reload Info("Unsubscribed from " + sub) } // openSubscriptionModal displays the "Add subscription" modal // It returns whether the user wanted to subscribe to feed/page. // The subscribed arg specifies whether this feed/page is already // subscribed to. func openSubscriptionModal(validFeed, subscribed bool) bool { // Reuses yesNoModal if viper.GetBool("a-general.color") { m := yesNoModal m.SetBackgroundColor(config.GetColor("subscription_modal_bg")) m.SetTextColor(config.GetColor("subscription_modal_text")) frame := yesNoModal.GetFrame() frame.SetBorderColor(config.GetColor("subscription_modal_text")) frame.SetTitleColor(config.GetColor("subscription_modal_text")) } else { m := yesNoModal m.SetBackgroundColor(tcell.ColorBlack) m.SetTextColor(tcell.ColorWhite) frame := yesNoModal.GetFrame() frame.SetBorderColor(tcell.ColorWhite) frame.SetTitleColor(tcell.ColorWhite) } if validFeed { yesNoModal.GetFrame().SetTitle("Feed Subscription") if subscribed { yesNoModal.SetText("You are already subscribed to this feed. Would you like to manually update it?") } else { yesNoModal.SetText("Would you like to subscribe to this feed?") } } else { yesNoModal.GetFrame().SetTitle("Page Subscription") if subscribed { yesNoModal.SetText("You are already subscribed to this page. Would you like to manually update it?") } else { yesNoModal.SetText("Would you like to subscribe to this page?") } } panels.ShowPanel(PanelYesNoModal) panels.SendToFront(PanelYesNoModal) App.SetFocus(yesNoModal) App.Draw() resp := <-yesNoCh panels.HidePanel(PanelYesNoModal) App.SetFocus(tabs[curTab].view) App.Draw() return resp } // getFeedFromPage is like subscriptions.GetFeed but takes a structs.Page as input. func getFeedFromPage(p *structs.Page) (*gofeed.Feed, bool) { parsed, _ := url.Parse(p.URL) filename := path.Base(parsed.Path) r := strings.NewReader(p.Raw) return subscriptions.GetFeed(p.RawMediatype, filename, r) } // addFeedDirect is only for adding feeds, not pages. // It's for when you already have a feed and know if it's tracked. // Used mainly by handleURL because it already did a lot of the work. // It returns a bool indicating whether the user actually wanted to // add the feed or not. // // Like addFeed, it should be called in a goroutine. func addFeedDirect(u string, feed *gofeed.Feed, tracked bool) bool { if openSubscriptionModal(true, tracked) { err := subscriptions.AddFeed(u, feed) if err != nil { Error("Feed Error", err.Error()) } return true } return false } // addFeed goes through the process of subscribing to the current page/feed. // It is the high-level way of doing it. It should be called in a goroutine. func addSubscription() { t := tabs[curTab] p := t.page if !t.hasContent() || t.isAnAboutPage() { // It's an about: page, or a malformed one return } feed, isFeed := getFeedFromPage(p) tracked := subscriptions.IsSubscribed(p.URL) if openSubscriptionModal(isFeed, tracked) { var err error if isFeed { err = subscriptions.AddFeed(p.URL, feed) } else { err = subscriptions.AddPage(p.URL, strings.NewReader(p.Raw)) } if err != nil { Error("Feed/Page Error", err.Error()) } } }