307 lines
9.8 KiB
Elixir
307 lines
9.8 KiB
Elixir
defmodule MicrowavepropWeb.ContactLive.Index do
|
|
@moduledoc "`/contacts` table with filter/sort + pagination over QSO records."
|
|
use MicrowavepropWeb, :live_view
|
|
use MicrowavepropWeb.LiveTableResource, schema: Microwaveprop.Radio.Contact
|
|
|
|
import Ecto.Query
|
|
|
|
alias Microwaveprop.Accounts.Scope
|
|
alias Microwaveprop.Accounts.User
|
|
alias Microwaveprop.Cache
|
|
alias Microwaveprop.Radio.Contact
|
|
alias Microwaveprop.Repo
|
|
|
|
@spec table_options() :: map()
|
|
def table_options do
|
|
%{
|
|
sorting: %{default_sort: [inserted_at: :desc]},
|
|
exports: %{formats: [:csv]}
|
|
}
|
|
end
|
|
|
|
@spec fields() :: keyword()
|
|
def fields do
|
|
[
|
|
id: %{label: "ID", hidden: true},
|
|
station1: %{label: "Station 1", sortable: true, searchable: true},
|
|
grid1: %{label: "Grid 1", sortable: true, searchable: true},
|
|
station2: %{label: "Station 2", sortable: true, searchable: true},
|
|
grid2: %{label: "Grid 2", sortable: true, searchable: true},
|
|
band: %{label: "Band", sortable: true, renderer: &band_cell/1},
|
|
mode: %{label: "Mode", sortable: true, searchable: true},
|
|
distance_km: %{label: "Distance", sortable: true, renderer: &distance_cell/1},
|
|
hrrr_status: %{label: "Enriched", renderer: &enrichment_cell/2},
|
|
qso_timestamp: %{label: "QSO (UTC)", sortable: true, renderer: &format_ts/1},
|
|
inserted_at: %{label: "Added (UTC)", sortable: true, renderer: &format_ts/1},
|
|
private: %{label: "Private", sortable: true, renderer: &private_cell/1}
|
|
]
|
|
end
|
|
|
|
@spec filters() :: list()
|
|
def filters, do: []
|
|
|
|
@spec actions() :: keyword()
|
|
def actions do
|
|
[
|
|
view: fn %{record: contact} ->
|
|
assigns = %{contact: contact}
|
|
|
|
~H"""
|
|
<.link navigate={~p"/contacts/#{@contact.id}"} class="btn btn-xs btn-ghost">
|
|
View
|
|
</.link>
|
|
"""
|
|
end
|
|
]
|
|
end
|
|
|
|
# Monthly chart geometry. Module attributes so the SVG layout
|
|
# constants stay in one place; assigns wire the values that the
|
|
# template renders into the markup.
|
|
@month_labels ~w(Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec)
|
|
@chart_max_bar_height 150
|
|
@chart_bar_width 36
|
|
@chart_bar_pitch 50
|
|
@chart_bar_offset 12
|
|
@chart_baseline 180
|
|
|
|
@impl true
|
|
def mount(_params, _session, socket) do
|
|
scope = socket.assigns[:current_scope]
|
|
base_query = visible_query(scope)
|
|
total = Repo.aggregate(base_query, :count, :id)
|
|
|
|
{:ok,
|
|
socket
|
|
|> assign(:page_title, "Contacts")
|
|
|> assign(:total_contacts, total)
|
|
|> assign(:monthly_bars, monthly_bars())
|
|
|> assign(:chart_baseline, @chart_baseline)
|
|
|> assign(:chart_bar_width, @chart_bar_width)
|
|
|> assign(:visible_fields, visible_fields_for(scope))}
|
|
end
|
|
|
|
@monthly_bars_cache_key {__MODULE__, :monthly_bars}
|
|
@monthly_bars_ttl_ms 60_000
|
|
|
|
# Counts every contact in the corpus regardless of viewer scope —
|
|
# the chart is a public-facing seasonal summary, not a personal
|
|
# view, so private contacts roll into the per-month totals like
|
|
# any other. Cached for 60s since data only changes on new inserts.
|
|
defp monthly_bars do
|
|
Cache.fetch_or_store(@monthly_bars_cache_key, @monthly_bars_ttl_ms, fn ->
|
|
by_month =
|
|
Contact
|
|
|> where([c], not is_nil(c.qso_timestamp))
|
|
|> group_by([c], fragment("EXTRACT(MONTH FROM ?)::int", c.qso_timestamp))
|
|
|> select([c], {fragment("EXTRACT(MONTH FROM ?)::int", c.qso_timestamp), count(c.id)})
|
|
|> Repo.all()
|
|
|> Map.new()
|
|
|
|
counts = Enum.map(1..12, fn m -> {m, Map.get(by_month, m, 0)} end)
|
|
max_count = counts |> Enum.map(&elem(&1, 1)) |> Enum.max()
|
|
|
|
Enum.map(counts, fn {month, count} ->
|
|
x = (month - 1) * @chart_bar_pitch + @chart_bar_offset
|
|
height = bar_height(count, max_count)
|
|
|
|
%{
|
|
month: month,
|
|
label: Enum.at(@month_labels, month - 1),
|
|
count: count,
|
|
x: x,
|
|
y: @chart_baseline - height,
|
|
height: height
|
|
}
|
|
end)
|
|
end)
|
|
end
|
|
|
|
defp bar_height(_count, 0), do: 0
|
|
defp bar_height(count, max_count), do: round(count / max_count * @chart_max_bar_height)
|
|
|
|
# Hide the Private column entirely unless this scope can actually see
|
|
# at least one private contact — avoids an always-empty column for
|
|
# visitors and owners who've never flagged one as private.
|
|
defp visible_fields_for(scope) do
|
|
if has_viewable_private?(scope) do
|
|
fields()
|
|
else
|
|
Keyword.delete(fields(), :private)
|
|
end
|
|
end
|
|
|
|
defp has_viewable_private?(%Scope{user: %User{is_admin: true}}) do
|
|
Repo.exists?(from(c in Contact, where: c.private == true))
|
|
end
|
|
|
|
defp has_viewable_private?(%Scope{user: %User{id: user_id}}) do
|
|
Repo.exists?(from(c in Contact, where: c.private == true and c.user_id == ^user_id))
|
|
end
|
|
|
|
defp has_viewable_private?(_), do: false
|
|
|
|
@doc false
|
|
# Called by LiveTable to get the base queryable. Must be a
|
|
# named function because the helper persists MFA across renders.
|
|
@spec visible_query_provider(scope_token :: term()) :: Ecto.Query.t()
|
|
def visible_query_provider(scope_token) do
|
|
scope_token
|
|
|> scope_from_token()
|
|
|> visible_query()
|
|
|> from(as: :resource)
|
|
end
|
|
|
|
defp visible_query(%Scope{user: %User{is_admin: true}}), do: Contact
|
|
|
|
defp visible_query(%Scope{user: %User{id: user_id}}) do
|
|
from(c in Contact, where: c.private == false or c.user_id == ^user_id)
|
|
end
|
|
|
|
defp visible_query(_), do: from(c in Contact, where: c.private == false)
|
|
|
|
# The data_provider MFA is serialized into the socket; a raw %Scope{}
|
|
# with associations isn't safe to store there. Rehydrate the minimal
|
|
# scope from the persisted token on each invocation.
|
|
defp scope_from_token({id, true}), do: %Scope{user: %User{id: id, is_admin: true}}
|
|
defp scope_from_token({id, false}), do: %Scope{user: %User{id: id, is_admin: false}}
|
|
defp scope_from_token(nil), do: nil
|
|
|
|
defp private_cell(true) do
|
|
assigns = %{}
|
|
|
|
~H"""
|
|
<span class="badge badge-sm badge-warning">Yes</span>
|
|
"""
|
|
end
|
|
|
|
defp private_cell(_), do: ""
|
|
|
|
@enrichment_fields [
|
|
{:hrrr_status, "HRRR"},
|
|
{:weather_status, "Weather"},
|
|
{:terrain_status, "Terrain"},
|
|
{:iemre_status, "IEMRE"}
|
|
]
|
|
@done_statuses [:complete, :unavailable]
|
|
|
|
defp enrichment_cell(_value, contact) do
|
|
details =
|
|
Enum.map(@enrichment_fields, fn {field, name} ->
|
|
{name, Map.get(contact, field)}
|
|
end)
|
|
|
|
done = Enum.count(details, fn {_, s} -> s in @done_statuses end)
|
|
failed = Enum.count(details, fn {_, s} -> s == :failed end)
|
|
|
|
{label, class} =
|
|
cond do
|
|
done == 4 -> {"Complete", "badge-success"}
|
|
failed > 0 -> {"Failed", "badge-error"}
|
|
done > 0 -> {"Partial", "badge-warning"}
|
|
true -> {"Pending", "badge-ghost"}
|
|
end
|
|
|
|
tooltip = Enum.map_join(details, ", ", fn {name, status} -> "#{name}: #{status}" end)
|
|
|
|
assigns = %{label: label, class: class, tooltip: tooltip}
|
|
|
|
~H"""
|
|
<span class={["badge badge-xs", @class]} title={@tooltip}>{@label}</span>
|
|
"""
|
|
end
|
|
|
|
defp band_cell(nil), do: ""
|
|
defp band_cell(%Decimal{} = d), do: Decimal.to_string(d, :normal)
|
|
defp band_cell(other), do: to_string(other)
|
|
|
|
defp distance_cell(nil), do: ""
|
|
defp distance_cell(km), do: Microwaveprop.Format.distance_km(km)
|
|
|
|
defp format_count(n) when is_integer(n) do
|
|
n
|
|
|> Integer.to_string()
|
|
|> String.reverse()
|
|
|> String.replace(~r/(\d{3})(?=\d)/, "\\1,")
|
|
|> String.reverse()
|
|
end
|
|
|
|
defp format_ts(nil), do: ""
|
|
defp format_ts(%DateTime{} = dt), do: Calendar.strftime(dt, "%Y-%m-%d %H:%M")
|
|
defp format_ts(%NaiveDateTime{} = dt), do: Calendar.strftime(dt, "%Y-%m-%d %H:%M")
|
|
defp format_ts(other), do: to_string(other)
|
|
|
|
@impl true
|
|
def render(assigns) do
|
|
~H"""
|
|
<Layouts.app flash={@flash} current_scope={@current_scope} max_width="max-w-7xl">
|
|
<.header>
|
|
Contacts
|
|
<:subtitle>
|
|
{format_count(@total_contacts)} total — sort or search by callsign, grid, or mode.
|
|
</:subtitle>
|
|
<:actions>
|
|
<.link navigate={~p"/submit"} class="btn btn-primary">
|
|
<.icon name="hero-plus" class="w-5 h-5" /> Submit Contact
|
|
</.link>
|
|
</:actions>
|
|
</.header>
|
|
|
|
<section class="bg-base-200 rounded-lg p-4 mb-6">
|
|
<h3 class="text-sm font-semibold opacity-70 uppercase tracking-wide mb-3">
|
|
Contacts by month <span class="text-xs font-normal opacity-60">(all years combined)</span>
|
|
</h3>
|
|
<svg viewBox="0 0 612 220" class="w-full h-48" role="img" aria-label="Monthly contact counts">
|
|
<line
|
|
x1="0"
|
|
y1={@chart_baseline}
|
|
x2="612"
|
|
y2={@chart_baseline}
|
|
class="stroke-base-content/30"
|
|
stroke-width="1"
|
|
/>
|
|
<%= for bar <- @monthly_bars do %>
|
|
<rect
|
|
x={bar.x}
|
|
y={bar.y}
|
|
width={@chart_bar_width}
|
|
height={bar.height}
|
|
class="fill-primary"
|
|
data-month={bar.month}
|
|
data-month-count={bar.count}
|
|
>
|
|
<title>{bar.label}: {bar.count}</title>
|
|
</rect>
|
|
<text
|
|
x={bar.x + @chart_bar_width / 2}
|
|
y={@chart_baseline + 16}
|
|
text-anchor="middle"
|
|
class="fill-base-content text-xs"
|
|
>
|
|
{bar.label}
|
|
</text>
|
|
<%= if bar.count > 0 do %>
|
|
<text
|
|
x={bar.x + @chart_bar_width / 2}
|
|
y={bar.y - 4}
|
|
text-anchor="middle"
|
|
class="fill-base-content text-xs"
|
|
>
|
|
{bar.count}
|
|
</text>
|
|
<% end %>
|
|
<% end %>
|
|
</svg>
|
|
</section>
|
|
|
|
<.live_table
|
|
fields={@visible_fields}
|
|
filters={filters()}
|
|
options={@options}
|
|
streams={@streams}
|
|
actions={actions()}
|
|
/>
|
|
</Layouts.app>
|
|
"""
|
|
end
|
|
end
|