Claudio Ortolina
692 lines
24 KiB
Elixir
692 lines
24 KiB
Elixir
defmodule MusicLibraryWeb.StatsLive.Index do
|
|
use MusicLibraryWeb, :live_view
|
|
|
|
import MusicLibrary.FormatNumber, only: [to_compact: 1]
|
|
import MusicLibraryWeb.ChartComponents
|
|
import MusicLibraryWeb.RecordComponents, only: [format_label: 1, type_label: 1]
|
|
import MusicLibraryWeb.StatsComponents
|
|
import MusicLibraryWeb.ScrobbleComponents
|
|
|
|
alias MusicLibrary.Assets.Transform
|
|
alias MusicLibrary.{Collection, ListeningStats, Records, Wishlist}
|
|
alias MusicLibraryWeb.ErrorMessages
|
|
alias MusicLibraryWeb.StatsLive.{TopAlbums, TopArtists}
|
|
alias Phoenix.LiveView.AsyncResult
|
|
|
|
@impl true
|
|
def render(assigns) do
|
|
~H"""
|
|
<Layouts.app
|
|
flash={@flash}
|
|
current_section={@current_section}
|
|
socket={@socket}
|
|
toasts_sync={assigns[:toasts_sync]}
|
|
>
|
|
<.section>
|
|
<:title>{gettext("Records")}</:title>
|
|
<div class="mt-5 grid min-h-35 grid-cols-3 gap-5 sm:grid-cols-5">
|
|
<.album_preview
|
|
record={@latest_record}
|
|
title={gettext("Latest purchase")}
|
|
class="col-span-3 sm:col-span-2"
|
|
/>
|
|
<.counter
|
|
title={gettext("Collection")}
|
|
count={@collection_count}
|
|
path={~p"/collection"}
|
|
/>
|
|
<.counter title={gettext("Wishlist")} count={@wishlist_count} path={~p"/wishlist"} />
|
|
<.counter
|
|
title={gettext("Scrobbles")}
|
|
count={to_compact(@scrobble_count)}
|
|
tooltip={@scrobble_count}
|
|
path={~p"/scrobbled-tracks"}
|
|
/>
|
|
</div>
|
|
</.section>
|
|
|
|
<div :if={@collection_count > 0} class="grid gap-x-5 md:grid-cols-2">
|
|
<.formats_stats collection_count_by_format={@collection_count_by_format} />
|
|
<.types_stats collection_count_by_type={@collection_count_by_type} />
|
|
</div>
|
|
|
|
<div class="grid grid-cols-1 gap-x-5 md:grid-cols-2 lg:grid-cols-3">
|
|
<TopArtists.live id="top-artists" timezone={@timezone} last_updated_uts={@last_updated_uts} />
|
|
<TopAlbums.live id="top-albums" timezone={@timezone} last_updated_uts={@last_updated_uts} />
|
|
<.async_result :let={records_on_this_day} assign={@on_this_day_records}>
|
|
<:loading>
|
|
<.section container_class="order-first lg:order-last">
|
|
<:title>{gettext("On This day")}</:title>
|
|
<div class="rounded-md bg-white p-6 shadow-sm dark:bg-zinc-800 animate-pulse">
|
|
<div class="mb-2 h-4 w-2/3 rounded bg-zinc-200 dark:bg-zinc-700"></div>
|
|
<div class="h-4 w-1/2 rounded bg-zinc-200 dark:bg-zinc-700"></div>
|
|
</div>
|
|
</.section>
|
|
</:loading>
|
|
<:failed :let={_reason}>
|
|
<.section container_class="order-first lg:order-last">
|
|
<:title>{gettext("On This day")}</:title>
|
|
<div class="rounded-md bg-white p-6 shadow-sm dark:bg-zinc-800 text-sm text-zinc-400 dark:text-zinc-500">
|
|
{gettext("Could not load records on this day.")}
|
|
</div>
|
|
</.section>
|
|
</:failed>
|
|
<.on_this_day
|
|
current_date={@current_date}
|
|
records_on_this_day={records_on_this_day}
|
|
/>
|
|
</.async_result>
|
|
</div>
|
|
|
|
<div id="daily-scrobble-counts">
|
|
<.section>
|
|
<:title>{gettext("Daily Scrobbles")}</:title>
|
|
<div class="mt-5 rounded-md bg-white shadow-sm dark:bg-zinc-800">
|
|
<.vertical_bar_chart
|
|
data={@daily_scrobble_counts}
|
|
color_class="bg-red-500 dark:bg-red-400"
|
|
label_fn={fn %{date: date, count: _count} -> Calendar.strftime(date, "%b %d") end}
|
|
value_fn={fn %{date: _date, count: count} -> count end}
|
|
/>
|
|
</div>
|
|
</.section>
|
|
</div>
|
|
|
|
<.scrobble_activity
|
|
scrobble_activity_mode={@scrobble_activity_mode}
|
|
streams={@streams}
|
|
/>
|
|
|
|
<.async_result :let={summary} assign={@collection_summary}>
|
|
<:loading>
|
|
<div class="grid grid-cols-1 gap-x-5 md:grid-cols-2 lg:grid-cols-3">
|
|
<.section>
|
|
<:title>{gettext("Loading…")}</:title>
|
|
<div class="mt-5 rounded-md bg-white p-6 shadow-sm dark:bg-zinc-800 animate-pulse">
|
|
<div class="mb-3 h-4 w-3/4 rounded bg-zinc-200 dark:bg-zinc-700"></div>
|
|
<div class="h-4 w-1/2 rounded bg-zinc-200 dark:bg-zinc-700"></div>
|
|
</div>
|
|
</.section>
|
|
</div>
|
|
</:loading>
|
|
<:failed :let={_reason}></:failed>
|
|
<div
|
|
:if={@collection_count > 0}
|
|
class="grid grid-cols-1 gap-x-5 md:grid-cols-2 lg:grid-cols-3"
|
|
>
|
|
<.top_collection_artists records_by_artist={summary.records_by_artist} />
|
|
<.top_collection_genres records_by_genre={summary.records_by_genre} />
|
|
<.top_release_years records_by_release_year={summary.records_by_release_year} />
|
|
</div>
|
|
</.async_result>
|
|
|
|
<.structured_modal
|
|
:if={@rule_picker_album_title}
|
|
id="rule-picker-modal"
|
|
on_close={JS.push("close_rule_picker")}
|
|
>
|
|
<.live_component
|
|
module={MusicLibraryWeb.ScrobbleRulePicker}
|
|
id="rule-picker"
|
|
album_title={@rule_picker_album_title}
|
|
/>
|
|
</.structured_modal>
|
|
</Layouts.app>
|
|
"""
|
|
end
|
|
|
|
@impl true
|
|
def mount(_params, _session, socket) do
|
|
current_date = DateTime.now!(socket.assigns.timezone) |> DateTime.to_date()
|
|
timezone = socket.assigns.timezone
|
|
|
|
if connected?(socket) do
|
|
ListeningStats.subscribe()
|
|
end
|
|
|
|
{:ok,
|
|
socket
|
|
|> stream_configure(:recent_tracks,
|
|
dom_id: fn %{track: track} -> "track-#{track.scrobbled_at_uts}" end
|
|
)
|
|
|> stream_configure(:recent_albums,
|
|
dom_id: fn %{album: album} -> "album-#{album.scrobbled_at_uts}" end
|
|
)
|
|
|> stream(:recent_tracks, [])
|
|
|> stream(:recent_albums, [])
|
|
|> assign(
|
|
daily_scrobble_counts: ListeningStats.daily_scrobble_counts(timezone: timezone),
|
|
current_date: current_date,
|
|
latest_record: Collection.get_latest_record(),
|
|
collection_count: Collection.count(),
|
|
wishlist_count: Wishlist.count(),
|
|
scrobble_count: ListeningStats.scrobble_count(),
|
|
collection_count_by_format: Collection.count_records_by_format(),
|
|
collection_count_by_type: Collection.count_records_by_type(),
|
|
last_updated_uts: nil,
|
|
scrobble_activity_mode: "albums",
|
|
page_title: gettext("Stats"),
|
|
current_section: :stats,
|
|
rule_picker_album_title: nil
|
|
)
|
|
|> assign_async(:collection_summary, fn ->
|
|
{:ok,
|
|
%{
|
|
collection_summary: %{
|
|
records_by_artist: Collection.count_records_by_artist(limit: 20),
|
|
records_by_genre: Collection.count_records_by_genre(limit: 20),
|
|
records_by_release_year: Collection.count_records_by_release_year(limit: 20)
|
|
}
|
|
}}
|
|
end)
|
|
|> assign_async(:on_this_day_records, fn ->
|
|
{:ok,
|
|
%{
|
|
on_this_day_records:
|
|
current_date
|
|
|> Collection.get_records_on_this_day()
|
|
|> Collection.group_records_by_release_group()
|
|
}}
|
|
end)
|
|
|> start_async(:scrobble_activity, fn ->
|
|
%{
|
|
recent_tracks: recent_tracks,
|
|
recent_albums: recent_albums
|
|
} = ListeningStats.recent_activity(timezone)
|
|
|
|
last_updated_uts =
|
|
if rt = List.first(recent_tracks), do: rt.track.scrobbled_at_uts
|
|
|
|
{:ok,
|
|
%{
|
|
recent_tracks: recent_tracks,
|
|
recent_albums: recent_albums,
|
|
last_updated_uts: last_updated_uts
|
|
}}
|
|
end)}
|
|
end
|
|
|
|
@impl true
|
|
def handle_async(:scrobble_activity, {:ok, {:ok, result}}, socket) do
|
|
%{recent_tracks: tracks, recent_albums: albums, last_updated_uts: uts} = result
|
|
|
|
{:noreply,
|
|
socket
|
|
|> assign(:last_updated_uts, uts)
|
|
|> stream(:recent_tracks, tracks, reset: true)
|
|
|> stream(:recent_albums, albums, reset: true)}
|
|
end
|
|
|
|
def handle_async(:scrobble_activity, {:ok, {:error, reason}}, socket) do
|
|
require Logger
|
|
Logger.error("Failed to load scrobble activity: #{inspect(reason)}")
|
|
|
|
{:noreply, socket}
|
|
end
|
|
|
|
def handle_async(:scrobble_activity, {:exit, reason}, socket) do
|
|
require Logger
|
|
Logger.error("Scrobble activity task exited: #{inspect(reason)}")
|
|
|
|
{:noreply, socket}
|
|
end
|
|
|
|
@impl true
|
|
def handle_event("refresh_scrobbles", _, socket) do
|
|
ListeningStats.refresh()
|
|
{:noreply, socket}
|
|
end
|
|
|
|
def handle_event("import", %{"id" => musicbrainz_id, "format" => format}, socket) do
|
|
case Records.import_from_musicbrainz_release(musicbrainz_id,
|
|
format: format,
|
|
purchased_at: nil
|
|
) do
|
|
{:ok, record} ->
|
|
{:noreply,
|
|
socket
|
|
|> put_toast(:info, gettext("Record wishlisted successfully"))
|
|
|> push_navigate(to: ~p"/wishlist/#{record.id}")}
|
|
|
|
{:error, reason} ->
|
|
{:noreply,
|
|
socket
|
|
|> put_toast(
|
|
:error,
|
|
gettext("Error wishlisting record") <> ": " <> ErrorMessages.friendly_message(reason)
|
|
)}
|
|
end
|
|
end
|
|
|
|
def handle_event("set_scrobble_activity_mode", %{"mode" => mode}, socket)
|
|
when mode in ["tracks", "albums"] do
|
|
{:noreply,
|
|
socket
|
|
|> assign(scrobble_activity_mode: mode)}
|
|
end
|
|
|
|
def handle_event("set_current_date", %{"current_date" => current_date}, socket) do
|
|
case Date.from_iso8601(current_date) do
|
|
{:ok, date} ->
|
|
records_on_this_day =
|
|
date
|
|
|> Collection.get_records_on_this_day()
|
|
|> Collection.group_records_by_release_group()
|
|
|
|
{:noreply,
|
|
socket
|
|
|> assign(:current_date, date)
|
|
|> assign(
|
|
:on_this_day_records,
|
|
AsyncResult.ok(
|
|
socket.assigns.on_this_day_records,
|
|
records_on_this_day
|
|
)
|
|
)}
|
|
|
|
{:error, _reason} ->
|
|
{:noreply, socket}
|
|
end
|
|
end
|
|
|
|
def handle_event("open_rule_picker", %{"album-title" => album_title}, socket) do
|
|
{:noreply, assign(socket, :rule_picker_album_title, album_title)}
|
|
end
|
|
|
|
def handle_event("close_rule_picker", _, socket) do
|
|
{:noreply, assign(socket, :rule_picker_album_title, nil)}
|
|
end
|
|
|
|
@impl true
|
|
def handle_info({MusicLibraryWeb.ScrobbleRulePicker, {:rule_created, _rule}}, socket) do
|
|
{:noreply,
|
|
socket
|
|
|> assign(:rule_picker_album_title, nil)
|
|
|> assign_scrobble_activity()}
|
|
end
|
|
|
|
def handle_info(%{track_count: 0}, socket) do
|
|
{:noreply, socket}
|
|
end
|
|
|
|
def handle_info(%{track_count: _count}, socket) do
|
|
{:noreply,
|
|
socket
|
|
|> assign_scrobble_activity()}
|
|
end
|
|
|
|
attr :records_by_release_year, :list, required: true
|
|
|
|
defp top_release_years(assigns) do
|
|
~H"""
|
|
<.section>
|
|
<:title>{gettext("Top 20 Release Years")}</:title>
|
|
<div class="mt-5 rounded-md bg-white shadow-sm dark:bg-zinc-800">
|
|
<.horizontal_bar_chart
|
|
data={@records_by_release_year}
|
|
color_class="bg-zinc-800 dark:bg-zinc-300"
|
|
label_fn={fn {year, _count} -> year end}
|
|
value_fn={fn {_year, count} -> count end}
|
|
datum_click={
|
|
fn {year, _count} ->
|
|
JS.navigate(~p"/collection?#{%{query: "release_year:#{year}"}}")
|
|
end
|
|
}
|
|
class="w-full"
|
|
/>
|
|
</div>
|
|
</.section>
|
|
"""
|
|
end
|
|
|
|
attr :records_by_genre, :list, required: true
|
|
|
|
defp top_collection_genres(assigns) do
|
|
~H"""
|
|
<.section>
|
|
<:title>{gettext("Top %{n} Collection Genres", %{n: length(@records_by_genre)})}</:title>
|
|
<div class="mt-5 rounded-md bg-white shadow-sm dark:bg-zinc-800">
|
|
<.horizontal_bar_chart
|
|
data={@records_by_genre}
|
|
color_class="bg-zinc-500"
|
|
label_fn={fn {genre, _count} -> genre end}
|
|
value_fn={fn {_genre, count} -> count end}
|
|
datum_click={
|
|
fn {genre, _count} ->
|
|
JS.navigate(~p"/collection?#{%{query: ~s(genre:"#{genre}")}}")
|
|
end
|
|
}
|
|
class="w-full"
|
|
/>
|
|
</div>
|
|
</.section>
|
|
"""
|
|
end
|
|
|
|
attr :records_by_artist, :list, required: true
|
|
|
|
defp top_collection_artists(assigns) do
|
|
~H"""
|
|
<.section>
|
|
<:title>{gettext("Top %{n} Collection Artists", %{n: length(@records_by_artist)})}</:title>
|
|
<div class="mt-5 rounded-md bg-white shadow-sm dark:bg-zinc-800">
|
|
<.horizontal_bar_chart
|
|
data={@records_by_artist}
|
|
color_class="bg-red-500"
|
|
label_fn={fn datum -> datum.name end}
|
|
value_fn={fn datum -> datum.count end}
|
|
datum_click={
|
|
fn datum ->
|
|
JS.navigate(~p"/artists/#{datum.id}")
|
|
end
|
|
}
|
|
class="w-full"
|
|
/>
|
|
</div>
|
|
</.section>
|
|
"""
|
|
end
|
|
|
|
attr :scrobble_activity_mode, :string, required: true
|
|
attr :streams, :any, required: true
|
|
|
|
defp scrobble_activity(assigns) do
|
|
~H"""
|
|
<div class="flow-root">
|
|
<.tabs id="scrobble-activity" class="mt-4">
|
|
<.section>
|
|
<:title>
|
|
{gettext("Scrobble activity")}
|
|
<.refresh_scrobbles_button />
|
|
</:title>
|
|
<:side_actions>
|
|
<.tabs_list active_tab={@scrobble_activity_mode} variant="segmented" size="xs">
|
|
<:tab
|
|
name="albums"
|
|
phx-click={JS.push("set_scrobble_activity_mode", value: %{mode: "albums"})}
|
|
>
|
|
{gettext("Albums")}
|
|
</:tab>
|
|
<:tab
|
|
name="tracks"
|
|
phx-click={JS.push("set_scrobble_activity_mode", value: %{mode: "tracks"})}
|
|
>
|
|
{gettext("Tracks")}
|
|
</:tab>
|
|
</.tabs_list>
|
|
</:side_actions>
|
|
<.tabs_panel name="albums" active={@scrobble_activity_mode == "albums"}>
|
|
<ul
|
|
id="scrobble-activity-albums"
|
|
role="list"
|
|
class="mt-4 rounded-md bg-white p-6 shadow-sm dark:bg-zinc-800"
|
|
phx-update="stream"
|
|
>
|
|
<li
|
|
:for={
|
|
{id,
|
|
%{
|
|
album: album,
|
|
artist_id: artist_id,
|
|
matching_records: matching_records,
|
|
cover_hash: cover_hash
|
|
}} <- @streams.recent_albums
|
|
}
|
|
id={id}
|
|
class="group"
|
|
>
|
|
<div class="relative pb-4 group-last:pb-0">
|
|
<span
|
|
class="absolute top-6 left-6 -ml-px h-full w-0.5 bg-zinc-200 group-last:hidden"
|
|
aria-hidden="true"
|
|
>
|
|
</span>
|
|
<div class="relative flex items-center justify-between space-x-3">
|
|
<div class="flex min-w-0 items-center justify-between space-x-4">
|
|
<img
|
|
class="size-12 rounded-md object-cover shadow-sm"
|
|
src={track_or_album_cover_url(album, cover_hash)}
|
|
alt={album.metadata.title}
|
|
onerror={"this.src = '" <> ~p"/images/cover-not-found.png" <> "';"}
|
|
/>
|
|
<div>
|
|
<p
|
|
:if={!artist_id(album, artist_id)}
|
|
class="block text-sm font-semibold text-zinc-500 dark:text-zinc-400"
|
|
>
|
|
{album.artist.name}
|
|
</p>
|
|
<.link
|
|
:if={artist_id(album, artist_id)}
|
|
class="block text-sm font-semibold text-zinc-700 hover:text-zinc-500 dark:text-zinc-400 dark:hover:text-zinc-300"
|
|
navigate={~p"/artists/#{artist_id(album, artist_id)}"}
|
|
>
|
|
{album.artist.name}
|
|
</.link>
|
|
<p class="text-sm font-semibold text-zinc-700 md:text-base dark:text-zinc-300">
|
|
{album.metadata.title}
|
|
</p>
|
|
<time
|
|
datetime={format_scrobbled_at_uts(album.scrobbled_at_uts)}
|
|
class="text-right text-xs whitespace-nowrap text-zinc-500 sm:text-sm dark:text-zinc-400"
|
|
>
|
|
{album.scrobbled_at_label}
|
|
</time>
|
|
<.album_metadata_tooltip album={album} />
|
|
</div>
|
|
</div>
|
|
|
|
<.record_status_badges
|
|
id={"status-#{album.scrobbled_at_uts}-albums"}
|
|
musicbrainz_id={album.metadata.musicbrainz_id}
|
|
matching_records={matching_records}
|
|
album_title={album.metadata.title}
|
|
/>
|
|
|
|
<.import_format_dropdown
|
|
:if={album.metadata.musicbrainz_id !== "" and matching_records == []}
|
|
id={"actions-#{album.scrobbled_at_uts}-albums"}
|
|
musicbrainz_id={album.metadata.musicbrainz_id}
|
|
/>
|
|
</div>
|
|
</div>
|
|
</li>
|
|
</ul>
|
|
</.tabs_panel>
|
|
<.tabs_panel name="tracks" active={@scrobble_activity_mode == "tracks"}>
|
|
<ul
|
|
id="scrobble-activity-tracks"
|
|
role="list"
|
|
class="mt-4 rounded-md bg-white p-6 shadow-sm dark:bg-zinc-800"
|
|
phx-update="stream"
|
|
>
|
|
<li
|
|
:for={
|
|
{id,
|
|
%{
|
|
track: track,
|
|
artist_id: artist_id,
|
|
matching_records: matching_records,
|
|
cover_hash: cover_hash
|
|
}} <- @streams.recent_tracks
|
|
}
|
|
id={id}
|
|
class="group"
|
|
>
|
|
<div class="relative pb-4 group-last:pb-0">
|
|
<span
|
|
class="absolute top-6 left-6 -ml-px h-full w-0.5 bg-zinc-200 group-last:hidden"
|
|
aria-hidden="true"
|
|
>
|
|
</span>
|
|
<div class="relative flex items-center justify-between space-x-3">
|
|
<div class="flex min-w-0 items-center justify-between space-x-4">
|
|
<img
|
|
class="size-12 rounded-md object-cover shadow-sm"
|
|
src={track_or_album_cover_url(track, cover_hash)}
|
|
alt={track.title}
|
|
onerror={"this.src = '" <> ~p"/images/cover-not-found.png" <> "';"}
|
|
/>
|
|
<div>
|
|
<p
|
|
:if={!artist_id(track, artist_id)}
|
|
class="block text-sm font-semibold text-zinc-500 dark:text-zinc-400"
|
|
>
|
|
{track.artist.name}
|
|
</p>
|
|
<.link
|
|
:if={artist_id(track, artist_id)}
|
|
class="block text-sm font-semibold text-zinc-700 hover:text-zinc-500 dark:text-zinc-400 dark:hover:text-zinc-300"
|
|
navigate={~p"/artists/#{artist_id(track, artist_id)}"}
|
|
>
|
|
{track.artist.name}
|
|
</.link>
|
|
<p class="text-sm font-semibold text-zinc-700 md:text-base dark:text-zinc-300">
|
|
{track.title}
|
|
</p>
|
|
<p class="text-sm font-semibold text-zinc-500 dark:text-zinc-400">
|
|
{track.album.title}
|
|
</p>
|
|
<time
|
|
datetime={format_scrobbled_at_uts(track.scrobbled_at_uts)}
|
|
class="text-right text-xs whitespace-nowrap text-zinc-500 sm:text-sm dark:text-zinc-400"
|
|
>
|
|
{track.scrobbled_at_label}
|
|
</time>
|
|
<.track_metadata_tooltip track={track} />
|
|
</div>
|
|
</div>
|
|
|
|
<.record_status_badges
|
|
id={"status-#{track.scrobbled_at_uts}-tracks"}
|
|
musicbrainz_id={track.album.musicbrainz_id}
|
|
matching_records={matching_records}
|
|
album_title={track.album.title}
|
|
/>
|
|
|
|
<.import_format_dropdown
|
|
:if={track.album.musicbrainz_id !== "" and matching_records == []}
|
|
id={"actions-#{track.scrobbled_at_uts}-tracks"}
|
|
musicbrainz_id={track.album.musicbrainz_id}
|
|
/>
|
|
</div>
|
|
</div>
|
|
</li>
|
|
</ul>
|
|
</.tabs_panel>
|
|
</.section>
|
|
</.tabs>
|
|
</div>
|
|
"""
|
|
end
|
|
|
|
attr :current_date, Date, required: true
|
|
attr :records_on_this_day, :list, required: true
|
|
|
|
defp on_this_day(assigns) do
|
|
~H"""
|
|
<.section container_class="order-first lg:order-last">
|
|
<:title>{gettext("On This day")}</:title>
|
|
<:side_actions>
|
|
<.form
|
|
:let={f}
|
|
for={to_form(%{"current_date" => @current_date})}
|
|
phx-change="set_current_date"
|
|
>
|
|
<.date_picker size="xs" field={f[:current_date]}>
|
|
<:outer_suffix>
|
|
<.button
|
|
size="xs"
|
|
type="button"
|
|
phx-click={JS.push("set_current_date", value: %{"current_date" => Date.utc_today()})}
|
|
>
|
|
{gettext("Today")}
|
|
</.button>
|
|
</:outer_suffix>
|
|
</.date_picker>
|
|
</.form>
|
|
</:side_actions>
|
|
<div class="rounded-md bg-white shadow-sm dark:bg-zinc-800">
|
|
<.records_on_this_day
|
|
current_date={@current_date}
|
|
records={@records_on_this_day}
|
|
record_show_path={fn record -> ~p"/collection/#{record}" end}
|
|
/>
|
|
</div>
|
|
</.section>
|
|
"""
|
|
end
|
|
|
|
attr :collection_count_by_type, :list, required: true
|
|
|
|
defp types_stats(assigns) do
|
|
~H"""
|
|
<.section>
|
|
<:title>{gettext("Types")}</:title>
|
|
<.counters_by_category
|
|
categories_with_counts={@collection_count_by_type}
|
|
category_format_fn={&type_label/1}
|
|
category_path_fn={fn type -> ~p"/collection?query=type:#{type}" end}
|
|
/>
|
|
</.section>
|
|
"""
|
|
end
|
|
|
|
attr :collection_count_by_format, :list, required: true
|
|
|
|
defp formats_stats(assigns) do
|
|
~H"""
|
|
<.section>
|
|
<:title>{gettext("Formats")}</:title>
|
|
<.counters_by_category
|
|
categories_with_counts={@collection_count_by_format}
|
|
category_format_fn={&format_label/1}
|
|
category_path_fn={fn format -> ~p"/collection?query=format:#{format}" end}
|
|
/>
|
|
</.section>
|
|
"""
|
|
end
|
|
|
|
defp assign_scrobble_activity(socket) do
|
|
timezone = socket.assigns.timezone
|
|
|
|
%{
|
|
recent_tracks: recent_tracks,
|
|
recent_albums: recent_albums
|
|
} = ListeningStats.recent_activity(timezone)
|
|
|
|
scrobble_count = ListeningStats.scrobble_count()
|
|
daily_scrobble_counts = ListeningStats.daily_scrobble_counts(timezone: timezone)
|
|
|
|
last_updated_uts =
|
|
if rt = List.first(recent_tracks) do
|
|
rt.track.scrobbled_at_uts
|
|
end
|
|
|
|
socket
|
|
|> assign(:last_updated_uts, last_updated_uts)
|
|
|> assign(:scrobble_count, scrobble_count)
|
|
|> assign(:daily_scrobble_counts, daily_scrobble_counts)
|
|
|> stream(:recent_tracks, recent_tracks, reset: true)
|
|
|> stream(:recent_albums, recent_albums, reset: true)
|
|
end
|
|
|
|
defp format_scrobbled_at_uts(uts) do
|
|
uts
|
|
|> DateTime.from_unix!()
|
|
|> DateTime.to_iso8601()
|
|
end
|
|
|
|
defp track_or_album_cover_url(track_or_album, nil) do
|
|
track_or_album.cover_url
|
|
end
|
|
|
|
defp track_or_album_cover_url(_track_or_album, cover_hash) do
|
|
~p"/assets/#{Transform.new(hash: cover_hash, width: 96)}"
|
|
end
|
|
|
|
defp artist_id(track_or_album, record_artist_id) do
|
|
record_artist_id || track_or_album.artist.musicbrainz_id
|
|
end
|
|
end
|