Add the calendar view (M10)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Sonnet 5.5
@@ -0,0 +1,466 @@
|
||||
package ui
|
||||
|
||||
import (
|
||||
"cmp"
|
||||
"context"
|
||||
"fmt"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/gdamore/tcell/v2"
|
||||
"github.com/rivo/tview"
|
||||
|
||||
"git.stinnesbeck.com/nils/arr-tui/internal/arr"
|
||||
"git.stinnesbeck.com/nils/arr-tui/internal/radarr"
|
||||
"git.stinnesbeck.com/nils/arr-tui/internal/sonarr"
|
||||
)
|
||||
|
||||
const (
|
||||
calendarDays = 14 // length of the window
|
||||
calendarStep = 7 // `[` and `]` move by this many days
|
||||
)
|
||||
|
||||
// calEntry is one line of the calendar: a movie release or an episode airing.
|
||||
type calEntry struct {
|
||||
day time.Time // local midnight of the day
|
||||
at time.Time // time of day, zero for date-only entries (movie releases)
|
||||
movie bool
|
||||
title string // plain title, for sorting
|
||||
label string // escaped title for display
|
||||
sub string // "S02E05 Welcome" or "Digital release"
|
||||
have bool
|
||||
monitored bool
|
||||
missing bool // aired already and not downloaded
|
||||
details detailText
|
||||
cover coverRef
|
||||
|
||||
movieID, episodeID int
|
||||
}
|
||||
|
||||
func (e calEntry) key() string {
|
||||
if e.movie {
|
||||
return fmt.Sprintf("m%d/%s/%s", e.movieID, e.sub, e.day.Format("2006-01-02"))
|
||||
}
|
||||
return fmt.Sprintf("e%d", e.episodeID)
|
||||
}
|
||||
|
||||
// localDay returns midnight of the date of t in the local zone.
|
||||
func localDay(t time.Time) time.Time {
|
||||
return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local)
|
||||
}
|
||||
|
||||
// releaseDay reads a movie release date. Radarr sends these as midnight UTC
|
||||
// timestamps meaning "this date", so the date is taken as written and not
|
||||
// shifted into the local zone.
|
||||
func releaseDay(s string) (time.Time, bool) {
|
||||
if s == "" {
|
||||
return time.Time{}, false
|
||||
}
|
||||
t, err := time.Parse(time.RFC3339, s)
|
||||
if err != nil {
|
||||
return time.Time{}, false
|
||||
}
|
||||
return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local), true
|
||||
}
|
||||
|
||||
// movieEntries returns an entry for every release date of the movie that falls
|
||||
// into [from, to] (local days).
|
||||
func movieEntries(m radarr.Movie, from, to time.Time, cover coverRef, now time.Time) []calEntry {
|
||||
var out []calEntry
|
||||
for _, rel := range []struct{ name, date string }{
|
||||
{"In cinemas", m.InCinemas}, {"Digital release", m.DigitalRelease}, {"Physical release", m.PhysicalRelease},
|
||||
} {
|
||||
day, ok := releaseDay(rel.date)
|
||||
if !ok || day.Before(from) || day.After(to) {
|
||||
continue
|
||||
}
|
||||
label := tview.Escape(m.Title)
|
||||
if m.Year > 0 {
|
||||
label += fmt.Sprintf(" (%d)", m.Year)
|
||||
}
|
||||
d := movieDetails(m)
|
||||
d.head += "Release: " + rel.name + ", " + day.Format("Mon 2 Jan 2006") + "\n"
|
||||
out = append(out, calEntry{
|
||||
day: day, movie: true, title: m.Title, label: label, sub: rel.name,
|
||||
have: m.HasFile, monitored: m.Monitored, missing: m.Monitored && !m.HasFile && !day.After(now),
|
||||
details: d, cover: cover, movieID: m.ID,
|
||||
})
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// episodeEntry converts an airing episode, or reports false if it has no usable date.
|
||||
func episodeEntry(e sonarr.Episode, from, to time.Time, cover coverRef, now time.Time) (calEntry, bool) {
|
||||
var day, at time.Time
|
||||
if t, err := time.Parse(time.RFC3339, e.AirDateUTC); err == nil {
|
||||
at = t.Local()
|
||||
day = localDay(at)
|
||||
} else if t, err := time.Parse("2006-01-02", e.AirDate); err == nil {
|
||||
day = time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local)
|
||||
} else {
|
||||
return calEntry{}, false
|
||||
}
|
||||
if day.Before(from) || day.After(to) {
|
||||
return calEntry{}, false
|
||||
}
|
||||
series := "Unknown series"
|
||||
var overview string
|
||||
if e.Series != nil {
|
||||
series = e.Series.Title
|
||||
overview = e.Series.Overview
|
||||
}
|
||||
if e.Overview != "" {
|
||||
overview = e.Overview
|
||||
}
|
||||
sub := fmt.Sprintf("S%02dE%02d %s", e.SeasonNumber, e.EpisodeNumber, e.Title)
|
||||
|
||||
head := "[::b]" + tview.Escape(series) + "[::-]\n" + tview.Escape(sub) + "\n"
|
||||
if !at.IsZero() {
|
||||
head += "Airs " + at.Format("Mon 2 Jan 15:04") + "\n"
|
||||
} else {
|
||||
head += "Airs " + day.Format("Mon 2 Jan") + "\n"
|
||||
}
|
||||
switch {
|
||||
case e.HasFile:
|
||||
head += "[green]Downloaded[-]\n"
|
||||
case !e.Monitored:
|
||||
head += "[gray]Not monitored[-]\n"
|
||||
default:
|
||||
head += "[yellow]Not downloaded[-]\n"
|
||||
}
|
||||
aired := !at.IsZero() && at.Before(now) || at.IsZero() && day.Before(localDay(now))
|
||||
return calEntry{
|
||||
day: day, at: at, title: series, label: tview.Escape(series), sub: sub,
|
||||
have: e.HasFile, monitored: e.Monitored, missing: e.Monitored && !e.HasFile && aired,
|
||||
details: detailText{head: head, plot: tview.Escape(overview)}, cover: cover,
|
||||
episodeID: e.ID,
|
||||
}, true
|
||||
}
|
||||
|
||||
// sortEntries orders by day, then time of day (date-only first), then title.
|
||||
func sortEntries(es []calEntry) {
|
||||
slices.SortStableFunc(es, func(a, b calEntry) int {
|
||||
return cmp.Or(
|
||||
a.day.Compare(b.day),
|
||||
a.at.Compare(b.at),
|
||||
strings.Compare(strings.ToLower(a.title), strings.ToLower(b.title)),
|
||||
strings.Compare(a.sub, b.sub),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
// dayLabel returns the date of a day and, for days near today, its relative
|
||||
// name: ("Wed 21 Oct", "Tomorrow").
|
||||
func dayLabel(day, today time.Time) (date, relative string) {
|
||||
date = day.Format("Mon 2 Jan")
|
||||
switch int(day.Sub(today).Round(24*time.Hour).Hours() / 24) { // Round: days are 23 or 25 hours long when the clocks change
|
||||
case 0:
|
||||
return date, "Today"
|
||||
case 1:
|
||||
return date, "Tomorrow"
|
||||
case -1:
|
||||
return date, "Yesterday"
|
||||
}
|
||||
return date, ""
|
||||
}
|
||||
|
||||
// calendarView lists the movies and episodes coming up in a two-week window.
|
||||
type calendarView struct {
|
||||
app *App
|
||||
radarr *radarr.Client
|
||||
sonarr *sonarr.Client
|
||||
|
||||
root *tview.Flex
|
||||
header *tview.TextView
|
||||
table *tview.Table
|
||||
details *detailPane
|
||||
|
||||
// UI-goroutine state.
|
||||
offset int // days from today to the first day shown; moved with [ and ]
|
||||
unmonitored bool
|
||||
entries []calEntry
|
||||
rows []calRow
|
||||
loaded bool
|
||||
gen int
|
||||
}
|
||||
|
||||
// calRow is a table row: a day header (entry == nil) or an entry.
|
||||
type calRow struct {
|
||||
day time.Time
|
||||
entry *calEntry
|
||||
}
|
||||
|
||||
func newCalendarView(app *App, r *radarr.Client, s *sonarr.Client) *calendarView {
|
||||
v := &calendarView{
|
||||
app: app, radarr: r, sonarr: s,
|
||||
header: tview.NewTextView().SetDynamicColors(true),
|
||||
table: tview.NewTable().SetSelectable(true, false).SetFixed(0, 0),
|
||||
details: newDetailPane(app),
|
||||
}
|
||||
v.table.SetBorder(true).SetTitle(" Upcoming ")
|
||||
v.root = tview.NewFlex().SetDirection(tview.FlexRow).
|
||||
AddItem(v.header, 1, 0, false).
|
||||
AddItem(tview.NewFlex().
|
||||
AddItem(v.table, 0, 3, true).
|
||||
AddItem(v.details, 0, 2, false), 0, 1, true)
|
||||
|
||||
v.table.SetSelectionChangedFunc(func(int, int) { v.renderDetails() })
|
||||
v.table.SetSelectedFunc(func(int, int) { v.open() })
|
||||
v.table.SetInputCapture(v.handleKey)
|
||||
v.render()
|
||||
return v
|
||||
}
|
||||
|
||||
func (v *calendarView) handleKey(ev *tcell.EventKey) *tcell.EventKey {
|
||||
if ev.Key() != tcell.KeyRune {
|
||||
return ev
|
||||
}
|
||||
switch ev.Rune() {
|
||||
case '[':
|
||||
v.offset -= calendarStep
|
||||
v.reload()
|
||||
case ']':
|
||||
v.offset += calendarStep
|
||||
v.reload()
|
||||
case 't':
|
||||
v.offset = 0
|
||||
v.reload()
|
||||
case 'u':
|
||||
v.unmonitored = !v.unmonitored
|
||||
v.reload()
|
||||
case 'r':
|
||||
v.reload()
|
||||
case 'i':
|
||||
v.open()
|
||||
case 's':
|
||||
v.search()
|
||||
default:
|
||||
return ev
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// window returns the first and last day shown.
|
||||
func (v *calendarView) window(now time.Time) (from, to time.Time) {
|
||||
from = localDay(now).AddDate(0, 0, v.offset)
|
||||
return from, from.AddDate(0, 0, calendarDays-1)
|
||||
}
|
||||
|
||||
func (v *calendarView) activate() { v.reload() }
|
||||
|
||||
// reload fetches both calendars in parallel.
|
||||
func (v *calendarView) reload() {
|
||||
v.gen++
|
||||
gen, unmonitored := v.gen, v.unmonitored
|
||||
now := time.Now()
|
||||
from, to := v.window(now)
|
||||
v.render()
|
||||
|
||||
go func() {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer cancel()
|
||||
var (
|
||||
wg sync.WaitGroup
|
||||
movies []radarr.Movie
|
||||
episodes []sonarr.Episode
|
||||
movieErr, tvErr error
|
||||
)
|
||||
wg.Add(2)
|
||||
go func() { defer wg.Done(); movies, movieErr = v.radarr.Calendar(ctx, from, to, unmonitored) }()
|
||||
go func() { defer wg.Done(); episodes, tvErr = v.sonarr.Calendar(ctx, from, to, unmonitored) }()
|
||||
wg.Wait()
|
||||
|
||||
var entries []calEntry
|
||||
for _, m := range movies {
|
||||
entries = append(entries, movieEntries(m, from, to, coverFor(v.radarr.Client, m.Images, true), now)...)
|
||||
}
|
||||
for _, e := range episodes {
|
||||
var cover coverRef
|
||||
if e.Series != nil {
|
||||
cover = coverFor(v.sonarr.Client, e.Series.Images, true)
|
||||
}
|
||||
if entry, ok := episodeEntry(e, from, to, cover, now); ok {
|
||||
entries = append(entries, entry)
|
||||
}
|
||||
}
|
||||
sortEntries(entries)
|
||||
|
||||
v.app.post(func() {
|
||||
v.app.SetService("Radarr", "", movieErr)
|
||||
v.app.SetService("Sonarr", "", tvErr)
|
||||
if gen != v.gen {
|
||||
return
|
||||
}
|
||||
for _, err := range []error{movieErr, tvErr} {
|
||||
if err != nil {
|
||||
v.app.SetMessage("[red]Calendar: " + tview.Escape(err.Error()))
|
||||
}
|
||||
}
|
||||
if movieErr == nil || tvErr == nil { // show what we got
|
||||
v.entries, v.loaded = entries, true
|
||||
}
|
||||
v.render()
|
||||
})
|
||||
}()
|
||||
}
|
||||
|
||||
func (v *calendarView) selected() (*calEntry, bool) {
|
||||
r, _ := v.table.GetSelection()
|
||||
if r < 0 || r >= len(v.rows) || v.rows[r].entry == nil {
|
||||
return nil, false
|
||||
}
|
||||
return v.rows[r].entry, true
|
||||
}
|
||||
|
||||
func (v *calendarView) render() {
|
||||
selKey := ""
|
||||
if e, ok := v.selected(); ok {
|
||||
selKey = e.key()
|
||||
}
|
||||
now := time.Now()
|
||||
today := localDay(now)
|
||||
from, to := v.window(now)
|
||||
|
||||
v.rows = v.rows[:0]
|
||||
var lastDay time.Time
|
||||
for i := range v.entries {
|
||||
e := &v.entries[i]
|
||||
if !e.day.Equal(lastDay) {
|
||||
v.rows = append(v.rows, calRow{day: e.day})
|
||||
lastDay = e.day
|
||||
}
|
||||
v.rows = append(v.rows, calRow{day: e.day, entry: e})
|
||||
}
|
||||
|
||||
v.table.Clear()
|
||||
selRow, firstEntry := 0, -1
|
||||
for i, r := range v.rows {
|
||||
if r.entry == nil {
|
||||
date, relative := dayLabel(r.day, today)
|
||||
v.table.SetCell(i, 0, tview.NewTableCell("[::b][yellow]"+date).SetSelectable(false))
|
||||
v.table.SetCell(i, 1, tview.NewTableCell("").SetSelectable(false))
|
||||
v.table.SetCell(i, 2, tview.NewTableCell("[yellow]"+relative).SetSelectable(false))
|
||||
v.table.SetCell(i, 3, tview.NewTableCell("").SetSelectable(false))
|
||||
continue
|
||||
}
|
||||
e := r.entry
|
||||
if firstEntry < 0 {
|
||||
firstEntry = i
|
||||
}
|
||||
when := " "
|
||||
if !e.at.IsZero() {
|
||||
when = e.at.Format("15:04") + " "
|
||||
}
|
||||
kind := "[blue]TV "
|
||||
if e.movie {
|
||||
kind = "[purple]Movie"
|
||||
}
|
||||
v.table.SetCell(i, 0, tview.NewTableCell(" "+when).SetSelectable(true))
|
||||
v.table.SetCell(i, 1, tview.NewTableCell(kind+"[-]"))
|
||||
v.table.SetCell(i, 2, tview.NewTableCell(e.label+" [gray]"+tview.Escape(e.sub)).SetExpansion(1))
|
||||
v.table.SetCell(i, 3, tview.NewTableCell(calStatus(*e)))
|
||||
if selKey != "" && e.key() == selKey {
|
||||
selRow = i
|
||||
}
|
||||
}
|
||||
|
||||
title := " Upcoming · " + from.Format("2 Jan") + " – " + to.Format("2 Jan") + " "
|
||||
if v.unmonitored {
|
||||
title += "· incl. unmonitored "
|
||||
}
|
||||
v.table.SetTitle(title)
|
||||
switch {
|
||||
case len(v.entries) == 0:
|
||||
msg := "Loading…"
|
||||
if v.loaded {
|
||||
msg = "Nothing in this period"
|
||||
}
|
||||
v.table.SetCell(0, 0, tview.NewTableCell("[gray]"+msg).SetSelectable(false))
|
||||
v.table.SetSelectable(false, false)
|
||||
v.table.Select(0, 0)
|
||||
default:
|
||||
v.table.SetSelectable(true, false)
|
||||
if selRow == 0 {
|
||||
selRow = firstEntry
|
||||
}
|
||||
v.table.Select(selRow, 0)
|
||||
if selRow == firstEntry {
|
||||
v.table.ScrollToBeginning()
|
||||
}
|
||||
}
|
||||
v.header.SetText("[::b]Calendar[::-] · [ ] move by a week · t today · u unmonitored · Enter releases · s search")
|
||||
v.renderDetails()
|
||||
}
|
||||
|
||||
// calStatus is the coloured status text of an entry.
|
||||
func calStatus(e calEntry) string {
|
||||
switch {
|
||||
case e.have:
|
||||
return "[green]✓ downloaded"
|
||||
case !e.monitored:
|
||||
return "[gray]unmonitored"
|
||||
case e.missing:
|
||||
return "[yellow]missing"
|
||||
}
|
||||
return "[gray]upcoming"
|
||||
}
|
||||
|
||||
func (v *calendarView) renderDetails() {
|
||||
if e, ok := v.selected(); ok {
|
||||
v.details.Show(e.details, e.cover)
|
||||
return
|
||||
}
|
||||
v.details.Clear()
|
||||
}
|
||||
|
||||
// open starts the interactive release search for the selected entry.
|
||||
func (v *calendarView) open() {
|
||||
e, ok := v.selected()
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
if e.movie {
|
||||
id, title := e.movieID, tview.Escape(e.title)
|
||||
v.app.openReleases("Releases for "+title,
|
||||
func(ctx context.Context) ([]arr.Release, error) { return v.radarr.Releases(ctx, id) },
|
||||
v.radarr.Grab)
|
||||
return
|
||||
}
|
||||
id := e.episodeID
|
||||
v.app.openReleases("Releases for "+e.label+" "+tview.Escape(e.sub),
|
||||
func(ctx context.Context) ([]arr.Release, error) { return v.sonarr.EpisodeReleases(ctx, id) },
|
||||
v.sonarr.Grab)
|
||||
}
|
||||
|
||||
// search starts an automatic search for the selected entry.
|
||||
func (v *calendarView) search() {
|
||||
e, ok := v.selected()
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
what := e.label
|
||||
if !e.movie {
|
||||
what += " " + tview.Escape(e.sub)
|
||||
}
|
||||
v.app.SetMessage("Searching for " + what + "…")
|
||||
movie, movieID, episodeID := e.movie, e.movieID, e.episodeID
|
||||
go func() {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
||||
defer cancel()
|
||||
var err error
|
||||
if movie {
|
||||
err = v.radarr.SearchMovie(ctx, movieID)
|
||||
} else {
|
||||
err = v.sonarr.SearchEpisode(ctx, episodeID)
|
||||
}
|
||||
v.app.post(func() {
|
||||
if err != nil {
|
||||
v.app.SetMessage("[red]" + tview.Escape(err.Error()))
|
||||
return
|
||||
}
|
||||
v.app.SetMessage("[green]Search started for " + what)
|
||||
})
|
||||
}()
|
||||
}
|
||||
Reference in New Issue
Block a user