0.2.75
This commit is contained in:
ponzischeme89
@@ -0,0 +1,296 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/ponzischeme89/memby/server/internal/store"
|
||||
)
|
||||
|
||||
// Watch time is Tracearr's answer, attributed to Emby accounts and read two ways: as figures
|
||||
// beside a person in the console, and as the weekly summary the television shows them.
|
||||
//
|
||||
// Everything about *when* a week begins and *how* a span is worded is in this file as pure
|
||||
// functions, because both readers have to agree — a console saying eleven hours and a digest
|
||||
// saying "10h 58m" for the same window is the sort of disagreement that makes an operator
|
||||
// stop trusting both numbers.
|
||||
|
||||
const (
|
||||
// digestWeekday and digestHour are when the weekly summary goes out, in the household's
|
||||
// own time. Sunday evening rather than Monday morning because the figure sent is
|
||||
// week-to-date: on a Monday it would be a summary of almost nothing, and by Sunday
|
||||
// evening it is the week the viewer actually had.
|
||||
digestWeekday = time.Sunday
|
||||
digestHour = 20
|
||||
|
||||
// watchTimeDigestFloor is the least viewing worth telling somebody about. A digest
|
||||
// reporting four minutes is a notification about a title somebody started and abandoned,
|
||||
// and a feed that reports those is one nobody opens.
|
||||
watchTimeDigestFloor = 20 * time.Minute
|
||||
)
|
||||
|
||||
// weekStartIn is the local Monday at midnight on or before now.
|
||||
//
|
||||
// Monday rather than Sunday because that is the week New Zealand keeps, and the boundary is
|
||||
// computed by *date* rather than by subtracting hours: a week containing a daylight-saving
|
||||
// change is 23 or 25 hours short or long, and now.Add(-7*24*time.Hour) would put the boundary
|
||||
// an hour inside the previous Sunday twice a year.
|
||||
func weekStartIn(now time.Time, location *time.Location) time.Time {
|
||||
local := now.In(location)
|
||||
offset := (int(local.Weekday()) + 6) % 7 // Monday becomes 0
|
||||
day := local.AddDate(0, 0, -offset)
|
||||
return time.Date(day.Year(), day.Month(), day.Day(), 0, 0, 0, 0, location)
|
||||
}
|
||||
|
||||
// monthStartIn is local midnight on the first of the month containing now.
|
||||
func monthStartIn(now time.Time, location *time.Location) time.Time {
|
||||
local := now.In(location)
|
||||
return time.Date(local.Year(), local.Month(), 1, 0, 0, 0, 0, location)
|
||||
}
|
||||
|
||||
// previousMonth is the closed window of the calendar month before the one containing now, and
|
||||
// the YYYY-MM key that names it. Half-open on the right, so a session that started on the
|
||||
// stroke of midnight belongs to exactly one of the two months.
|
||||
func previousMonth(now time.Time, location *time.Location) (from, to time.Time, key string) {
|
||||
to = monthStartIn(now, location)
|
||||
from = to.AddDate(0, -1, 0)
|
||||
return from, to, from.Format("2006-01")
|
||||
}
|
||||
|
||||
// weekKey names a week the way the source key needs it — a stable string that changes exactly
|
||||
// once per week. ISO year-and-week, so the last days of December cannot collide with the
|
||||
// first days of January.
|
||||
func weekKey(now time.Time, location *time.Location) string {
|
||||
year, week := weekStartIn(now, location).ISOWeek()
|
||||
return fmt.Sprintf("%04d-W%02d", year, week)
|
||||
}
|
||||
|
||||
// weeklyDigestDue is the whole schedule rule, kept pure so the send window is testable
|
||||
// without waiting a week for one.
|
||||
//
|
||||
// The task runs hourly and this says yes for every run from the appointed hour to the end of
|
||||
// that day, rather than only on the hour itself: a container restarted at eight on a Sunday
|
||||
// evening, or a run that failed, must still deliver the summary. Sending it twice is prevented
|
||||
// by the notification's source key rather than by narrowing this window, which is the same
|
||||
// trade the *arr lifecycle scanner makes — an idempotent write is a better guard than a timer.
|
||||
func weeklyDigestDue(now time.Time, location *time.Location) bool {
|
||||
local := now.In(location)
|
||||
return local.Weekday() == digestWeekday && local.Hour() >= digestHour
|
||||
}
|
||||
|
||||
// monthlyDigestDue says whether the *previous* month may be summarised yet. Any run at or
|
||||
// after the appointed hour qualifies, so a gateway that was switched off over the turn of the
|
||||
// month still delivers the summary when it comes back rather than skipping it for ever.
|
||||
func monthlyDigestDue(now time.Time, location *time.Location) bool {
|
||||
return now.In(location).Hour() >= digestHour
|
||||
}
|
||||
|
||||
// formatWatchDuration is how a span of viewing is worded everywhere Memby says one out loud.
|
||||
//
|
||||
// Rounded to the minute, because a viewing figure carrying seconds invites somebody to
|
||||
// reconcile it against something, and nothing it is derived from is accurate to the second.
|
||||
func formatWatchDuration(d time.Duration) string {
|
||||
minutes := int(d.Round(time.Minute) / time.Minute)
|
||||
if minutes <= 0 {
|
||||
return "no time"
|
||||
}
|
||||
hours := minutes / 60
|
||||
minutes %= 60
|
||||
switch {
|
||||
case hours == 0:
|
||||
return fmt.Sprintf("%d min", minutes)
|
||||
case minutes == 0 && hours == 1:
|
||||
return "1 hour"
|
||||
case minutes == 0:
|
||||
return fmt.Sprintf("%d hours", hours)
|
||||
default:
|
||||
return fmt.Sprintf("%dh %dm", hours, minutes)
|
||||
}
|
||||
}
|
||||
|
||||
// weeklyDigestMessage is the sentence a viewer reads. Both figures are in it because the
|
||||
// question "have I watched a lot this week" is only answerable beside the month it sits in —
|
||||
// and the month is dropped when the two are the same span, which is what the first week of a
|
||||
// month looks like, rather than printing the same number twice.
|
||||
func weeklyDigestMessage(week, month time.Duration, topTitle string) string {
|
||||
var b strings.Builder
|
||||
b.WriteString("You watched " + formatWatchDuration(week) + " this week")
|
||||
if month > week {
|
||||
b.WriteString(", and " + formatWatchDuration(month) + " so far this month")
|
||||
}
|
||||
b.WriteString(".")
|
||||
if title := strings.TrimSpace(topTitle); title != "" {
|
||||
b.WriteString(" Mostly " + title + ".")
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// monthlyDigestMessage summarises a month that has ended. It names the month, because unlike
|
||||
// the weekly note this can arrive days after the window it describes closed.
|
||||
func monthlyDigestMessage(month time.Duration, monthName, topTitle string) string {
|
||||
var b strings.Builder
|
||||
b.WriteString("You watched " + formatWatchDuration(month) + " in " + monthName + ".")
|
||||
if title := strings.TrimSpace(topTitle); title != "" {
|
||||
b.WriteString(" Most of it on " + title + ".")
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// watchTimeSummary is one account's figures as the console reads them. Matched is carried
|
||||
// because "nobody by that name in Tracearr" and "somebody who has watched nothing" are
|
||||
// different facts, and a console that showed both as a row of zeroes would leave an operator
|
||||
// investigating a viewer rather than an integration.
|
||||
type watchTimeSummary struct {
|
||||
Matched bool `json:"matched"`
|
||||
Username string `json:"tracearrUsername,omitempty"`
|
||||
WeekMs int64 `json:"weekMs"`
|
||||
MonthMs int64 `json:"monthMs"`
|
||||
TotalMs int64 `json:"totalMs"`
|
||||
WeekSessions int `json:"weekSessions"`
|
||||
MonthSessions int `json:"monthSessions"`
|
||||
LastWatchedAt *time.Time `json:"lastWatchedAt,omitempty"`
|
||||
}
|
||||
|
||||
// tracearrEnabled is whether there is anything to read at all. Every watch-time reader checks
|
||||
// it first, so a household running no Tracearr pays no query for a feature it cannot have.
|
||||
func (s *Server) tracearrEnabled() bool {
|
||||
return strings.TrimSpace(s.cfg.TracearrURL) != "" && strings.TrimSpace(s.cfg.TracearrAPIKey) != ""
|
||||
}
|
||||
|
||||
// attributeWatchTime maps Tracearr identities onto Emby user ids.
|
||||
//
|
||||
// The username is the join, because it is the identity the two systems genuinely share and
|
||||
// the only one present for a viewer the recommendation builder has never profiled. The
|
||||
// recorded identity map wins where it exists: it is what the builder actually matched, so a
|
||||
// household that has since renamed somebody in one system keeps their figures instead of
|
||||
// silently reporting zero.
|
||||
//
|
||||
// It is a pure function over both readings so the matching rule can be tested without a
|
||||
// database, and so the console and the digest cannot attribute the same rows differently.
|
||||
func attributeWatchTime(
|
||||
accounts []watchTimeAccount,
|
||||
totals []store.WatchTimeTotals,
|
||||
identities map[string]store.RecommendationIdentity,
|
||||
) map[string]store.WatchTimeTotals {
|
||||
byName := make(map[string]store.WatchTimeTotals, len(totals))
|
||||
byID := make(map[string]store.WatchTimeTotals, len(totals))
|
||||
for _, entry := range totals {
|
||||
if key := strings.ToLower(strings.TrimSpace(entry.Username)); key != "" {
|
||||
byName[key] = entry
|
||||
}
|
||||
if entry.TracearrUserID != "" {
|
||||
byID[entry.TracearrUserID] = entry
|
||||
}
|
||||
}
|
||||
out := make(map[string]store.WatchTimeTotals, len(accounts))
|
||||
for _, account := range accounts {
|
||||
identity := identities[account.ID]
|
||||
if identity.TracearrUserID != "" {
|
||||
if entry, ok := byID[identity.TracearrUserID]; ok {
|
||||
out[account.ID] = entry
|
||||
continue
|
||||
}
|
||||
}
|
||||
for _, candidate := range []string{identity.Username, account.Username} {
|
||||
key := strings.ToLower(strings.TrimSpace(candidate))
|
||||
if key == "" {
|
||||
continue
|
||||
}
|
||||
if entry, ok := byName[key]; ok {
|
||||
out[account.ID] = entry
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// watchTimeAccount is the little of an account the attribution rule needs. Declared here
|
||||
// rather than taking store.MembyAccount so the rule can be tested with two fields and so the
|
||||
// digest, which works from sessions rather than from accounts, can use it too.
|
||||
type watchTimeAccount struct {
|
||||
ID string
|
||||
Username string
|
||||
}
|
||||
|
||||
// watchTimeForAccounts is the console's reading: one grouped query, attributed, and never
|
||||
// fatal. A Tracearr table that will not read must not cost the operator the account list.
|
||||
func (s *Server) watchTimeForAccounts(
|
||||
ctx context.Context,
|
||||
accounts []watchTimeAccount,
|
||||
) map[string]store.WatchTimeTotals {
|
||||
if !s.tracearrEnabled() || len(accounts) == 0 {
|
||||
return nil
|
||||
}
|
||||
location := s.householdLocation()
|
||||
now := time.Now()
|
||||
totals, err := s.store.TracearrWatchTime(ctx, weekStartIn(now, location), monthStartIn(now, location))
|
||||
if err != nil {
|
||||
s.loggerFor(ctx).Warn("watch time read failed", "error", err)
|
||||
return nil
|
||||
}
|
||||
identities, err := s.store.TracearrIdentities(ctx)
|
||||
if err != nil {
|
||||
// The username join still works without it; only a renamed viewer loses their
|
||||
// figures, which is better than the whole page losing them.
|
||||
s.loggerFor(ctx).Warn("Tracearr identity map unavailable", "error", err)
|
||||
identities = map[string]store.RecommendationIdentity{}
|
||||
}
|
||||
return attributeWatchTime(accounts, totals, identities)
|
||||
}
|
||||
|
||||
// summariseWatchTime turns the store's row into what the console reads, including the case
|
||||
// where there is no row.
|
||||
func summariseWatchTime(totals store.WatchTimeTotals, matched bool) watchTimeSummary {
|
||||
if !matched {
|
||||
return watchTimeSummary{}
|
||||
}
|
||||
return watchTimeSummary{
|
||||
Matched: true, Username: totals.Username,
|
||||
WeekMs: totals.WeekMs, MonthMs: totals.MonthMs, TotalMs: totals.TotalMs,
|
||||
WeekSessions: totals.WeekSessions, MonthSessions: totals.MonthSessions,
|
||||
LastWatchedAt: totals.LastWatchedAt,
|
||||
}
|
||||
}
|
||||
|
||||
// indexWatchTimeRanges keys a window's rows for lookup by either identity. Both maps are
|
||||
// built because the digest resolves the same two ways attributeWatchTime does — by the id the
|
||||
// recommendation builder recorded where there is one, and by name otherwise.
|
||||
func indexWatchTimeRanges(windows []store.WatchTimeRange) (byID, byName map[string]store.WatchTimeRange) {
|
||||
byID = make(map[string]store.WatchTimeRange, len(windows))
|
||||
byName = make(map[string]store.WatchTimeRange, len(windows))
|
||||
for _, window := range windows {
|
||||
if window.TracearrUserID != "" {
|
||||
byID[window.TracearrUserID] = window
|
||||
}
|
||||
if key := strings.ToLower(strings.TrimSpace(window.Username)); key != "" {
|
||||
byName[key] = window
|
||||
}
|
||||
}
|
||||
return byID, byName
|
||||
}
|
||||
|
||||
// lookupWatchTimeRange finds one person's row in an indexed window.
|
||||
func lookupWatchTimeRange(
|
||||
byID, byName map[string]store.WatchTimeRange,
|
||||
identity store.RecommendationIdentity,
|
||||
username string,
|
||||
) store.WatchTimeRange {
|
||||
if identity.TracearrUserID != "" {
|
||||
if window, ok := byID[identity.TracearrUserID]; ok {
|
||||
return window
|
||||
}
|
||||
}
|
||||
for _, candidate := range []string{identity.Username, username} {
|
||||
key := strings.ToLower(strings.TrimSpace(candidate))
|
||||
if key == "" {
|
||||
continue
|
||||
}
|
||||
if window, ok := byName[key]; ok {
|
||||
return window
|
||||
}
|
||||
}
|
||||
return store.WatchTimeRange{}
|
||||
}
|
||||
Reference in New Issue
Block a user