346 lines
10 KiB
Go
346 lines
10 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/ponzischeme89/memby/server/internal/recommend"
|
|
"github.com/ponzischeme89/memby/server/internal/sonarr"
|
|
"github.com/ponzischeme89/memby/server/internal/store"
|
|
)
|
|
|
|
const sonarrCalendarCachePrefix = "sonarr:calendar:"
|
|
const sonarrPrerollCachePrefix = "sonarr:preroll:"
|
|
|
|
type prerollScheduleResponse struct {
|
|
Today []prerollScheduleEntry `json:"today"`
|
|
ThisWeek []prerollScheduleEntry `json:"thisWeek"`
|
|
}
|
|
|
|
type prerollScheduleEntry struct {
|
|
Series string `json:"series"`
|
|
Episode string `json:"episode"`
|
|
EpisodeCode string `json:"episodeCode"`
|
|
Schedule string `json:"schedule"`
|
|
Availability string `json:"availability,omitempty"`
|
|
}
|
|
|
|
func (s *Server) handlePreroll(w http.ResponseWriter, r *http.Request, _ store.Session) {
|
|
if s.sonarr == nil {
|
|
writeJSON(w, http.StatusOK, emptyPrerollSchedule())
|
|
return
|
|
}
|
|
schedule, err := s.sonarrPrerollSchedule(r.Context())
|
|
if err != nil {
|
|
// Pre-roll is decorative and must never become a playback dependency.
|
|
s.log.Warn("preroll schedule unavailable", "error", err)
|
|
writeJSON(w, http.StatusOK, emptyPrerollSchedule())
|
|
return
|
|
}
|
|
writeJSON(w, http.StatusOK, schedule)
|
|
}
|
|
|
|
func (s *Server) sonarrPrerollSchedule(ctx context.Context) (prerollScheduleResponse, error) {
|
|
location := s.cfg.SonarrLocation
|
|
if location == nil {
|
|
location = time.Local
|
|
}
|
|
now := time.Now().In(location)
|
|
dayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, location)
|
|
key := sonarrPrerollCachePrefix + dayStart.Format("2006-01-02")
|
|
if raw, err := s.cache.Get(ctx, key); err == nil {
|
|
var cached prerollScheduleResponse
|
|
if json.Unmarshal(raw, &cached) == nil {
|
|
return normalizePrerollSchedule(cached), nil
|
|
}
|
|
}
|
|
|
|
s.sonarrMu.Lock()
|
|
defer s.sonarrMu.Unlock()
|
|
if raw, err := s.cache.Get(ctx, key); err == nil {
|
|
var cached prerollScheduleResponse
|
|
if json.Unmarshal(raw, &cached) == nil {
|
|
return normalizePrerollSchedule(cached), nil
|
|
}
|
|
}
|
|
|
|
episodes, err := s.sonarr.Calendar(ctx, dayStart, dayStart.AddDate(0, 0, 7))
|
|
if err != nil {
|
|
return emptyPrerollSchedule(), err
|
|
}
|
|
schedule := buildPrerollSchedule(episodes, now, location)
|
|
if raw, err := json.Marshal(schedule); err == nil {
|
|
if cacheErr := s.cache.Set(ctx, key, raw, s.cfg.SonarrTTL); cacheErr != nil {
|
|
s.log.Warn("preroll schedule cache write failed", "error", cacheErr)
|
|
}
|
|
}
|
|
return schedule, nil
|
|
}
|
|
|
|
func buildPrerollSchedule(
|
|
episodes []sonarr.Episode,
|
|
now time.Time,
|
|
location *time.Location,
|
|
) prerollScheduleResponse {
|
|
sort.SliceStable(episodes, func(i, j int) bool {
|
|
if episodes[i].AirDateUTC == nil {
|
|
return false
|
|
}
|
|
if episodes[j].AirDateUTC == nil {
|
|
return true
|
|
}
|
|
return episodes[i].AirDateUTC.Before(*episodes[j].AirDateUTC)
|
|
})
|
|
todayEnd := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, location).AddDate(0, 0, 1)
|
|
result := emptyPrerollSchedule()
|
|
for _, episode := range episodes {
|
|
if episode.AirDateUTC == nil {
|
|
continue
|
|
}
|
|
airTime := episode.AirDateUTC.In(location)
|
|
entry := prerollScheduleEntry{
|
|
Series: episode.Series.Title,
|
|
Episode: episode.Title,
|
|
EpisodeCode: fmt.Sprintf("S%02dE%02d", episode.SeasonNumber, episode.EpisodeNumber),
|
|
Availability: prerollAvailability(episode),
|
|
}
|
|
if airTime.Before(todayEnd) {
|
|
entry.Schedule = airTime.Format("3:04 PM")
|
|
if len(result.Today) < 4 {
|
|
result.Today = append(result.Today, entry)
|
|
}
|
|
} else {
|
|
entry.Schedule = airTime.Format("Monday · 3:04 PM")
|
|
if len(result.ThisWeek) < 6 {
|
|
result.ThisWeek = append(result.ThisWeek, entry)
|
|
}
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func prerollAvailability(episode sonarr.Episode) string {
|
|
switch {
|
|
case episode.HasFile:
|
|
return "Downloaded"
|
|
case episode.Grabbed:
|
|
return "Downloading"
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func emptyPrerollSchedule() prerollScheduleResponse {
|
|
return prerollScheduleResponse{
|
|
Today: []prerollScheduleEntry{},
|
|
ThisWeek: []prerollScheduleEntry{},
|
|
}
|
|
}
|
|
|
|
func normalizePrerollSchedule(value prerollScheduleResponse) prerollScheduleResponse {
|
|
if value.Today == nil {
|
|
value.Today = []prerollScheduleEntry{}
|
|
}
|
|
if value.ThisWeek == nil {
|
|
value.ThisWeek = []prerollScheduleEntry{}
|
|
}
|
|
return value
|
|
}
|
|
|
|
// sonarrScheduleItem deliberately looks enough like an Emby item to reuse the fast home
|
|
// card renderer, while its Memby fields mark it as informational and non-playable.
|
|
type sonarrScheduleItem struct {
|
|
ID string `json:"Id"`
|
|
Name string `json:"Name"`
|
|
Type string `json:"Type"`
|
|
Overview string `json:"Overview,omitempty"`
|
|
ProductionYear int `json:"ProductionYear,omitempty"`
|
|
RunTimeTicks int64 `json:"RunTimeTicks,omitempty"`
|
|
Genres []string `json:"Genres"`
|
|
ImageTags map[string]string `json:"ImageTags"`
|
|
BackdropImageTags []string `json:"BackdropImageTags"`
|
|
MembySource string `json:"MembySource"`
|
|
MembyEpisodeTitle string `json:"MembyEpisodeTitle"`
|
|
MembyEpisodeCode string `json:"MembyEpisodeCode"`
|
|
MembyAirsAt string `json:"MembyAirsAt,omitempty"`
|
|
MembyAddedAt string `json:"MembyAddedAt,omitempty"`
|
|
MembyAirLabel string `json:"MembyAirLabel"`
|
|
MembyAvailability string `json:"MembyAvailability"`
|
|
MembyAvailabilityText string `json:"MembyAvailabilityText"`
|
|
MembyPlayable bool `json:"MembyPlayable"`
|
|
}
|
|
|
|
func (s *Server) sonarrAiringTodayRow(ctx context.Context) (*recommend.Row, error) {
|
|
if s.sonarr == nil {
|
|
return nil, nil
|
|
}
|
|
location := s.cfg.SonarrLocation
|
|
if location == nil {
|
|
location = time.Local
|
|
}
|
|
now := time.Now().In(location)
|
|
dayStart := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, location)
|
|
cacheKey := sonarrCalendarCachePrefix + dayStart.Format("2006-01-02")
|
|
|
|
if row := s.cachedSonarrRow(ctx, cacheKey); row != nil {
|
|
return row, nil
|
|
}
|
|
|
|
// A shared lock prevents several users opening the app together from stampeding
|
|
// Sonarr on the one cache miss each day.
|
|
s.sonarrMu.Lock()
|
|
defer s.sonarrMu.Unlock()
|
|
if row := s.cachedSonarrRow(ctx, cacheKey); row != nil {
|
|
return row, nil
|
|
}
|
|
|
|
episodes, err := s.sonarr.Calendar(ctx, dayStart, dayStart.AddDate(0, 0, 1))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
row, err := buildSonarrRow(episodes, now, location)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
body, err := json.Marshal(row)
|
|
if err == nil {
|
|
if cacheErr := s.cache.Set(ctx, cacheKey, body, s.cfg.SonarrTTL); cacheErr != nil {
|
|
s.log.Warn("sonarr calendar cache write failed", "error", cacheErr)
|
|
}
|
|
}
|
|
return row, nil
|
|
}
|
|
|
|
func (s *Server) cachedSonarrRow(ctx context.Context, key string) *recommend.Row {
|
|
raw, err := s.cache.Get(ctx, key)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
var row recommend.Row
|
|
if json.Unmarshal(raw, &row) != nil {
|
|
return nil
|
|
}
|
|
return &row
|
|
}
|
|
|
|
func buildSonarrRow(episodes []sonarr.Episode, now time.Time, location *time.Location) (*recommend.Row, error) {
|
|
sort.SliceStable(episodes, func(i, j int) bool {
|
|
if episodes[i].AirDateUTC == nil {
|
|
return false
|
|
}
|
|
if episodes[j].AirDateUTC == nil {
|
|
return true
|
|
}
|
|
return episodes[i].AirDateUTC.Before(*episodes[j].AirDateUTC)
|
|
})
|
|
|
|
items := make([]json.RawMessage, 0, len(episodes))
|
|
for _, episode := range episodes {
|
|
item := toSonarrScheduleItem(episode, now, location)
|
|
raw, err := json.Marshal(item)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, raw)
|
|
}
|
|
return &recommend.Row{
|
|
ID: "sonarr-airing-today",
|
|
Title: "Shows airing today",
|
|
Kind: "schedule",
|
|
Items: items,
|
|
}, nil
|
|
}
|
|
|
|
func toSonarrScheduleItem(episode sonarr.Episode, now time.Time, location *time.Location) sonarrScheduleItem {
|
|
seriesID := episode.SeriesID
|
|
if episode.Series.ID > 0 {
|
|
seriesID = episode.Series.ID
|
|
}
|
|
item := sonarrScheduleItem{
|
|
ID: fmt.Sprintf("sonarr:%d:%d", seriesID, episode.ID),
|
|
Name: episode.Series.Title,
|
|
Type: "MembySonarrEpisode",
|
|
Overview: episode.Overview,
|
|
ProductionYear: episode.Series.Year,
|
|
RunTimeTicks: int64(episode.Runtime) * 600_000_000,
|
|
Genres: nonNilStrings(episode.Series.Genres),
|
|
ImageTags: map[string]string{},
|
|
BackdropImageTags: []string{},
|
|
MembySource: "sonarr",
|
|
MembyEpisodeTitle: episode.Title,
|
|
MembyEpisodeCode: fmt.Sprintf("S%02dE%02d", episode.SeasonNumber, episode.EpisodeNumber),
|
|
MembyPlayable: false,
|
|
}
|
|
if hasCover(episode.Series.Images, "poster") {
|
|
item.ImageTags["Primary"] = "sonarr"
|
|
}
|
|
if hasCover(episode.Series.Images, "fanart") {
|
|
item.BackdropImageTags = []string{"sonarr"}
|
|
}
|
|
|
|
if episode.AirDateUTC != nil {
|
|
airTime := episode.AirDateUTC.In(location)
|
|
item.MembyAirsAt = airTime.Format(time.RFC3339)
|
|
if airTime.After(now) {
|
|
item.MembyAirLabel = "Airs today at " + airTime.Format("3:04 PM")
|
|
} else {
|
|
item.MembyAirLabel = "Aired today at " + airTime.Format("3:04 PM")
|
|
}
|
|
} else {
|
|
item.MembyAirLabel = "Airs today"
|
|
}
|
|
|
|
addedAt := episodeFileAddedAt(episode)
|
|
switch {
|
|
case episode.HasFile:
|
|
item.MembyAvailability = "available"
|
|
item.MembyAvailabilityText = "Downloaded"
|
|
if addedAt != nil {
|
|
localAdded := addedAt.In(location)
|
|
item.MembyAddedAt = localAdded.Format(time.RFC3339)
|
|
item.MembyAvailabilityText = "Added at " + localAdded.Format("3:04 PM")
|
|
}
|
|
case episode.Grabbed:
|
|
item.MembyAvailability = "downloading"
|
|
item.MembyAvailabilityText = "Downloading"
|
|
case !episode.Monitored:
|
|
item.MembyAvailability = "unmonitored"
|
|
item.MembyAvailabilityText = "Not monitored"
|
|
case episode.AirDateUTC != nil && episode.AirDateUTC.Before(now):
|
|
item.MembyAvailability = "awaiting"
|
|
item.MembyAvailabilityText = "Awaiting download"
|
|
default:
|
|
item.MembyAvailability = "upcoming"
|
|
item.MembyAvailabilityText = "Upcoming"
|
|
}
|
|
return item
|
|
}
|
|
|
|
func episodeFileAddedAt(episode sonarr.Episode) *time.Time {
|
|
if episode.EpisodeFile == nil {
|
|
return nil
|
|
}
|
|
return episode.EpisodeFile.DateAdded
|
|
}
|
|
|
|
func hasCover(images []sonarr.Image, coverType string) bool {
|
|
for _, image := range images {
|
|
if strings.EqualFold(image.CoverType, coverType) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func nonNilStrings(values []string) []string {
|
|
if values == nil {
|
|
return []string{}
|
|
}
|
|
return values
|
|
}
|