Cleanup files batch 400

extra/lib/plausible_web/live/customer_support/team/components/consolidated_views.ex

@@ -1,112 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Team.Components.ConsolidatedViews do
-  @moduledoc """
-  Lists ConsolidatedViews of a team and allows creating one if none exist. Current
-  limitation is one consolidated view per team, which always includes all sites of
-  this team.
-  """
-  use PlausibleWeb, :live_component
-  import PlausibleWeb.CustomerSupport.Live
-  alias Plausible.ConsolidatedView
-  alias Plausible.Stats
-
-  def update(%{team: team}, socket) do
-    consolidated_view = ConsolidatedView.get(team)
-
-    sparkline_intervals =
-      with true <- connected?(socket),
-           {:ok, sparkline} <- Stats.Sparkline.safe_overview_24h(consolidated_view) do
-        sparkline.intervals
-      else
-        _ ->
-          Stats.Sparkline.empty_24h_intervals()
-      end
-
-    {:ok,
-     assign(socket,
-       team: team,
-       consolidated_views: List.wrap(consolidated_view),
-       sparkline_intervals: sparkline_intervals
-     )}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div data-test-id="consolidated-views-tab-content" class="mt-2 mb-4">
-      <%= if Enum.empty?(@consolidated_views) do %>
-        <div class="mx-auto flex flex-col items-center">
-          <p>This team does not have a consolidated view yet.</p>
-          <.button class="mx-auto" phx-click="create-consolidated-view" phx-target={@myself}>
-            Create one
-          </.button>
-        </div>
-      <% else %>
-        <.table rows={@consolidated_views}>
-          <:thead>
-            <.th>Domain</.th>
-            <.th>Timezone</.th>
-            <.th>Available?</.th>
-            <.th invisible>Dashboard</.th>
-            <.th invisible>24H</.th>
-            <.th invisible>Delete</.th>
-          </:thead>
-
-          <:tbody :let={consolidated_view}>
-            <.td>{consolidated_view.domain}</.td>
-            <.td>{consolidated_view.timezone}</.td>
-            <.td>{availability(@team)}</.td>
-            <.td>
-              <.styled_link
-                new_tab={true}
-                href={Routes.stats_path(PlausibleWeb.Endpoint, :stats, consolidated_view.domain, [])}
-              >
-                Dashboard
-              </.styled_link>
-            </.td>
-
-            <.td>
-              <span class="h-[24px] text-indigo-500">
-                <PlausibleWeb.Live.Components.Visitors.chart
-                  intervals={@sparkline_intervals}
-                  height={20}
-                />
-              </span>
-            </.td>
-            <.td>
-              <.delete_button
-                phx-click="delete-consolidated-view"
-                phx-target={@myself}
-                data-confirm="Are you sure you want to delete this consolidated view? All existing consolidated view configuration will be lost. The view itself will be recreated whenever eligible subscription/trial accesses /sites for that team."
-              />
-            </.td>
-          </:tbody>
-        </.table>
-      <% end %>
-    </div>
-    """
-  end
-
-  def handle_event("create-consolidated-view", _, socket) do
-    case ConsolidatedView.enable(socket.assigns.team) do
-      {:ok, consolidated_view} ->
-        success("Consolidated view created")
-        {:noreply, assign(socket, consolidated_views: [consolidated_view])}
-
-      {:error, reason} ->
-        failure("Could not create consolidated view. Reason: #{inspect(reason)}")
-        {:noreply, socket}
-    end
-  end
-
-  def handle_event("delete-consolidated-view", _, socket) do
-    ConsolidatedView.disable(socket.assigns.team)
-    success("Deleted consolidated view")
-    {:noreply, assign(socket, consolidated_views: [])}
-  end
-
-  defp availability(team) do
-    case Plausible.Billing.Feature.ConsolidatedView.check_availability(team) do
-      :ok -> "Yes"
-      {:error, :upgrade_required} -> "No - upgrade required"
-    end
-  end
-end

extra/lib/plausible_web/live/customer_support/team/components/members.ex

@@ -1,94 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Team.Components.Members do
-  @moduledoc """
-  Team members component - handles team member management
-  """
-  use PlausibleWeb, :live_component
-  import PlausibleWeb.CustomerSupport.Live
-  alias Plausible.Teams
-
-  def update(%{team: team}, socket) do
-    {:ok, refresh_members(socket, team)}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div class="mt-2">
-      <.table rows={Teams.Management.Layout.sorted_for_display(@team_layout)}>
-        <:thead>
-          <.th>User</.th>
-          <.th>Sessions</.th>
-          <.th>Type</.th>
-          <.th>Role</.th>
-        </:thead>
-        <:tbody :let={{_, member}}>
-          <.td truncate>
-            <div :if={member.id != 0}>
-              <.styled_link
-                patch={Routes.customer_support_user_path(PlausibleWeb.Endpoint, :show, member.id)}
-                class="cursor-pointer flex block items-center"
-              >
-                <img
-                  src={Plausible.Auth.User.profile_img_url(%Plausible.Auth.User{email: member.email})}
-                  class="mr-4 w-6 rounded-full bg-gray-300"
-                />
-                {member.name} &lt;{member.email}&gt;
-              </.styled_link>
-            </div>
-            <div :if={member.id == 0} class="flex items-center">
-              <img
-                src={Plausible.Auth.User.profile_img_url(%Plausible.Auth.User{email: member.email})}
-                class="mr-4 w-6 rounded-full bg-gray-300"
-              />
-              {member.name} &lt;{member.email}&gt;
-            </div>
-          </.td>
-          <.td>
-            {if member.type == :membership, do: @session_counts[member.meta.user.id] || 0, else: 0}
-          </.td>
-          <.td>
-            <div class="flex items-center gap-x-1">
-              <span :if={member.type == :membership && member.meta.user.type == :sso}>SSO </span>{member.type}
-
-              <.delete_button
-                :if={member.type == :membership && member.meta.user.type == :sso}
-                id={"deprovision-sso-user-#{member.id}"}
-                phx-click="deprovision-sso-user"
-                phx-value-identifier={member.id}
-                phx-target={@myself}
-                class="text-sm"
-                icon={:user_minus}
-                data-confirm="Are you sure you want to deprovision SSO user and convert them to a standard user? This will sign them out and force to use regular e-mail/password combination to log in again."
-              />
-            </div>
-          </.td>
-          <.td>
-            {member.role}
-          </.td>
-        </:tbody>
-      </.table>
-    </div>
-    """
-  end
-
-  def handle_event("deprovision-sso-user", %{"identifier" => user_id}, socket) do
-    [id: String.to_integer(user_id)]
-    |> Plausible.Auth.find_user_by()
-    |> Plausible.Auth.SSO.deprovision_user!()
-
-    success("SSO user deprovisioned")
-    {:noreply, refresh_members(socket, socket.assigns.team)}
-  end
-
-  defp refresh_members(socket, team) do
-    team_layout = Teams.Management.Layout.init(team)
-
-    session_counts =
-      team_layout
-      |> Enum.map(fn {_, entry} -> if entry.type == :membership, do: entry.meta.user end)
-      |> Enum.reject(&is_nil/1)
-      |> Plausible.Auth.UserSessions.count_for_users()
-      |> Enum.into(%{})
-
-    assign(socket, team: team, team_layout: team_layout, session_counts: session_counts)
-  end
-end

extra/lib/plausible_web/live/customer_support/team/components/overview.ex

@@ -1,74 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Team.Components.Overview do
-  @moduledoc """
-  Team overview component - handles team basic info, trial dates, notes
-  """
-  use PlausibleWeb, :live_component
-  import PlausibleWeb.CustomerSupport.Live
-
-  def update(%{team: team}, socket) do
-    changeset = Plausible.Teams.Team.crm_changeset(team, %{})
-    form = to_form(changeset)
-
-    {:ok, assign(socket, team: team, form: form)}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div class="mt-8">
-      <.form :let={f} for={@form} phx-submit="save-team" phx-target={@myself}>
-        <.input field={f[:trial_expiry_date]} type="date" label="Trial Expiry Date" />
-        <.input field={f[:accept_traffic_until]} type="date" label="Accept traffic Until" />
-        <.input
-          type="checkbox"
-          field={f[:allow_next_upgrade_override]}
-          label="Allow Next Upgrade Override"
-        />
-
-        <.input type="textarea" field={f[:notes]} label="Notes" />
-
-        <div class="flex justify-between">
-          <.button type="submit">
-            Save
-          </.button>
-
-          <.button
-            phx-target={@myself}
-            phx-click="delete-team"
-            data-confirm="Are you sure you want to delete this team?"
-            theme="danger"
-          >
-            Delete Team
-          </.button>
-        </div>
-      </.form>
-    </div>
-    """
-  end
-
-  def handle_event("save-team", %{"team" => params}, socket) do
-    changeset = Plausible.Teams.Team.crm_changeset(socket.assigns.team, params)
-
-    case Plausible.Repo.update(changeset) do
-      {:ok, team} ->
-        success("Team saved")
-        {:noreply, assign(socket, team: team, form: to_form(changeset))}
-
-      {:error, changeset} ->
-        failure("Error saving team: #{inspect(changeset.errors)}")
-        {:noreply, assign(socket, form: to_form(changeset))}
-    end
-  end
-
-  def handle_event("delete-team", _params, socket) do
-    case Plausible.Teams.delete(socket.assigns.team) do
-      {:ok, :deleted} ->
-        navigate_with_success(Routes.customer_support_path(socket, :index), "Team deleted")
-        {:noreply, socket}
-
-      {:error, :active_subscription} ->
-        failure("The team has an active subscription which must be canceled first.")
-
-        {:noreply, socket}
-    end
-  end
-end

extra/lib/plausible_web/live/customer_support/team/components/sites.ex

@@ -1,245 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Team.Components.Sites do
-  @moduledoc """
-  Team sites component - handles team sites listing
-  """
-  use PlausibleWeb, :live_component
-
-  import Ecto.Query, except: [update: 2, update: 3]
-  import PlausibleWeb.Live.Components.Pagination
-
-  alias Plausible.Repo
-  alias Plausible.Site
-  alias Plausible.Sites.Index
-
-  @page_size 24
-
-  def update(%{team: team, tab_params: tab_params}, socket) do
-    team = Repo.preload(team, :owners)
-    owner = List.first(team.owners)
-
-    socket =
-      assign_new(socket, :index_state, fn ->
-        Index.build(owner, team: team, sort_by: :traffic, sort_direction: :desc)
-      end)
-
-    page =
-      Index.paginate(socket.assigns.index_state, page: tab_params["page"], page_size: @page_size)
-
-    sites = fetch_sites(page.entries)
-
-    hourly_stats = build_hourly_stats(sites, socket)
-
-    uri =
-      Routes.customer_support_team_path(PlausibleWeb.Endpoint, :show, team.id, tab: "sites")
-      |> URI.parse()
-
-    {:ok,
-     assign(socket,
-       team: team,
-       sites: sites,
-       hourly_stats: hourly_stats,
-       page_number: page.page_number,
-       total_pages: page.total_pages,
-       total_entries: page.total_entries,
-       uri: uri
-     )}
-  end
-
-  def update(%{team: team}, socket) do
-    update(%{team: team, tab_params: %{}}, socket)
-  end
-
-  def handle_event("sort", %{"by" => by}, socket) do
-    sort_by = parse_sort_by(by)
-    current_state = socket.assigns.index_state
-    current_sort_by = current_state.sort_by
-
-    sort_direction =
-      case sort_by do
-        ^current_sort_by ->
-          flip_direction(current_state.sort_direction)
-
-        :traffic ->
-          :desc
-
-        :alnum ->
-          :asc
-      end
-
-    new_state = Index.sort(current_state, sort_by: sort_by, sort_direction: sort_direction)
-    page = Index.paginate(new_state, page: 1, page_size: @page_size)
-    sites = fetch_sites(page.entries)
-
-    hourly_stats = build_hourly_stats(sites, socket)
-
-    {:noreply,
-     assign(socket,
-       index_state: new_state,
-       sites: sites,
-       page_number: page.page_number,
-       total_pages: page.total_pages,
-       total_entries: page.total_entries,
-       hourly_stats: hourly_stats
-     )}
-  end
-
-  def render(assigns) do
-    assigns =
-      assign(assigns,
-        sort_by: assigns.index_state.sort_by,
-        sort_direction: assigns.index_state.sort_direction
-      )
-
-    ~H"""
-    <div class="mt-2">
-      <.table rows={@sites}>
-        <:thead>
-          <th
-            scope="col"
-            class="px-6 first:pl-0 last:pr-0 py-3 text-left text-sm font-semibold cursor-pointer select-none"
-            phx-click="sort"
-            phx-value-by="alnum"
-            phx-target={@myself}
-          >
-            Domain <.sort_arrow active={@sort_by == :alnum} direction={@sort_direction} />
-          </th>
-          <.th>Previous Domain</.th>
-          <.th>Timezone</.th>
-          <.th invisible>Settings</.th>
-          <.th invisible>Dashboard</.th>
-          <th
-            scope="col"
-            class="max-w-40 px-6 first:pl-0 last:pr-0 py-3 text-left text-sm font-semibold cursor-pointer select-none"
-            phx-click="sort"
-            phx-value-by="traffic"
-            phx-target={@myself}
-          >
-            Traffic <.sort_arrow active={@sort_by == :traffic} direction={@sort_direction} />
-          </th>
-        </:thead>
-        <:tbody :let={site}>
-          <.td>
-            <div class="flex items-center">
-              <img
-                src="/favicon/sources/{site.domain}"
-                onerror="this.onerror=null; this.src='/favicon/sources/placeholder';"
-                class="w-4 h-4 flex-shrink-0 mt-px mr-2"
-              />
-              <.styled_link
-                patch={Routes.customer_support_site_path(PlausibleWeb.Endpoint, :show, site.id)}
-                class="cursor-pointer flex block items-center"
-              >
-                {site.domain}
-
-                <span :if={@index_state.pins[site.id]}>
-                  <PlausibleWeb.Components.Icons.pin_icon class="w-4 ml-2" filled={true} />
-                </span>
-              </.styled_link>
-            </div>
-          </.td>
-          <.td>{site.domain_changed_from || "--"}</.td>
-          <.td>{site.timezone}</.td>
-          <.td>
-            <.styled_link
-              new_tab={true}
-              href={Routes.stats_path(PlausibleWeb.Endpoint, :stats, site.domain, [])}
-            >
-              Dashboard
-            </.styled_link>
-          </.td>
-          <.td>
-            <.styled_link
-              new_tab={true}
-              href={Routes.site_path(PlausibleWeb.Endpoint, :settings_general, site.domain, [])}
-            >
-              Settings
-            </.styled_link>
-          </.td>
-          <.td max_width="max-w-40">
-            <span class="h-[24px] text-indigo-500">
-              <PlausibleWeb.Live.Components.Visitors.chart
-                :if={is_map(@hourly_stats[site.domain])}
-                intervals={@hourly_stats[site.domain].intervals}
-                height={20}
-              />
-            </span>
-            <span class="text-[10px]">
-              Unique visitors: {if is_map(@hourly_stats),
-                do: @hourly_stats[site.domain][:visitors] || 0,
-                else: 0}
-            </span>
-          </.td>
-        </:tbody>
-      </.table>
-      <.pagination
-        :if={@total_pages > 1}
-        id="sites-pagination"
-        uri={@uri}
-        page_number={@page_number}
-        total_pages={@total_pages}
-      >
-        Total of <span class="font-medium">{@total_entries}</span>
-        sites. Page {@page_number} of {@total_pages}
-      </.pagination>
-    </div>
-    """
-  end
-
-  defp fetch_sites([]), do: []
-
-  defp fetch_sites(site_ids) do
-    by_id =
-      from(s in Site.regular(),
-        where: s.id in ^site_ids,
-        select: {s.id, s}
-      )
-      |> Repo.all()
-      |> Map.new()
-
-    Enum.map(site_ids, fn id -> Map.get(by_id, id) end)
-  end
-
-  defp build_hourly_stats(sites, socket) do
-    if connected?(socket) do
-      Plausible.Stats.Sparkline.parallel_overview(sites)
-    else
-      sites
-      |> Enum.map(fn site ->
-        {site.domain,
-         %{
-           intervals: Plausible.Stats.Sparkline.empty_24h_intervals(),
-           visitors: 0,
-           visitors_change: 0
-         }}
-      end)
-      |> Map.new()
-    end
-  end
-
-  defp parse_sort_by("alnum"), do: :alnum
-  defp parse_sort_by(_), do: :traffic
-
-  defp flip_direction(:asc), do: :desc
-  defp flip_direction(:desc), do: :asc
-
-  attr :active, :boolean, required: true
-  attr :direction, :atom, required: true
-
-  defp sort_arrow(%{active: false} = assigns) do
-    ~H"""
-    <span class="opacity-30">↕</span>
-    """
-  end
-
-  defp sort_arrow(%{direction: :asc} = assigns) do
-    ~H"""
-    <span>↑</span>
-    """
-  end
-
-  defp sort_arrow(assigns) do
-    ~H"""
-    <span>↓</span>
-    """
-  end
-end

extra/lib/plausible_web/live/customer_support/team/components/sso.ex

@@ -1,114 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.Team.Components.SSO do
-  @moduledoc """
-  Team SSO component - handles SSO integration management
-  """
-  use PlausibleWeb, :live_component
-  import PlausibleWeb.CustomerSupport.Live
-  alias Plausible.Auth.SSO
-
-  def update(%{team: team}, socket) do
-    sso_integration = get_sso_integration(team)
-    {:ok, assign(socket, team: team, sso_integration: sso_integration)}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div>
-      <div :if={@sso_integration}>
-        <div class="mt-4 mb-4 text-gray-900 dark:text-gray-400">
-          <.table rows={
-            [
-              {"configured?", SSO.Integration.configured?(@sso_integration)},
-              {"IDP Sign-in URL", @sso_integration.config.idp_signin_url},
-              {"IDP Entity ID", @sso_integration.config.idp_entity_id}
-            ] ++ Enum.into(Map.from_struct(@team.policy), [])
-          }>
-            <:tbody :let={{k, v}}>
-              <.td>{k}</.td>
-              <.td>{v}</.td>
-            </:tbody>
-          </.table>
-        </div>
-
-        <.table rows={@sso_integration.sso_domains}>
-          <:thead>
-            <.th>Domain</.th>
-            <.th>Status</.th>
-            <.th></.th>
-          </:thead>
-          <:tbody :let={sso_domain}>
-            <.td>
-              {sso_domain.domain}
-            </.td>
-            <.td>
-              {sso_domain.status}
-              <span :if={sso_domain.verified_via}>
-                (via {sso_domain.verified_via} at {Calendar.strftime(
-                  sso_domain.last_verified_at,
-                  "%b %-d, %Y"
-                )})
-              </span>
-            </.td>
-            <.td actions>
-              <.delete_button
-                id={"remove-sso-domain-#{sso_domain.identifier}"}
-                phx-click="remove-sso-domain"
-                phx-value-identifier={sso_domain.identifier}
-                phx-target={@myself}
-                class="text-sm text-red-600"
-                data-confirm={"Are you sure you want to remove domain '#{sso_domain.domain}'? All SSO users will be deprovisioned and logged out."}
-              />
-            </.td>
-          </:tbody>
-        </.table>
-
-        <div class="flex justify-end">
-          <.button
-            data-confirm="Are you sure you want to remove this SSO team integration, including all its domains and users?"
-            id="remove-sso-integration"
-            phx-click="remove-sso-integration"
-            phx-target={@myself}
-            theme="danger"
-          >
-            Remove Integration
-          </.button>
-        </div>
-      </div>
-      <div :if={!@sso_integration} class="text-center py-8 text-gray-500">
-        <p>No SSO integration configured for this team.</p>
-      </div>
-    </div>
-    """
-  end
-
-  def handle_event("remove-sso-integration", _, socket) do
-    :ok = SSO.remove_integration(socket.assigns.sso_integration, force_deprovision?: true)
-
-    socket =
-      socket
-      |> assign(sso_integration: nil)
-      |> push_navigate(
-        to: Routes.customer_support_team_path(socket, :show, socket.assigns.team.id)
-      )
-
-    success("SSO integration removed")
-
-    {:noreply, socket}
-  end
-
-  def handle_event("remove-sso-domain", %{"identifier" => i}, socket) do
-    domain = Enum.find(socket.assigns.sso_integration.sso_domains, &(&1.identifier == i))
-    :ok = SSO.Domains.remove(domain, force_deprovision?: true)
-
-    success("SSO domain removed")
-
-    {:noreply, assign(socket, sso_integration: get_sso_integration(socket.assigns.team))}
-  end
-
-  defp get_sso_integration(team) do
-    case SSO.get_integration_for(team) do
-      {:error, :not_found} -> nil
-      {:ok, integration} -> integration
-    end
-  end
-end

extra/lib/plausible_web/live/customer_support/user.ex

@@ -1,115 +0,0 @@
-defmodule PlausibleWeb.Live.CustomerSupport.User do
-  @moduledoc """
-  User coordinator LiveView for Customer Support interface.
-
-  Manages tab-based navigation and delegates rendering to specialized 
-  components: Overview and API Keys.
-  """
-  use PlausibleWeb.CustomerSupport.Live
-
-  import Ecto.Query
-  alias Plausible.Repo
-
-  alias PlausibleWeb.CustomerSupport.User.Components.{
-    Overview,
-    Keys
-  }
-
-  def handle_params(%{"id" => user_id} = params, _uri, socket) do
-    tab = params["tab"] || "overview"
-    user = Resource.User.get(user_id)
-
-    if user do
-      keys_count = count_keys(user)
-
-      socket =
-        socket
-        |> assign(:user, user)
-        |> assign(:tab, tab)
-        |> assign(:keys_count, keys_count)
-
-      {:noreply, go_to_tab(socket, tab, params, :user, tab_component(tab))}
-    else
-      {:noreply, redirect(socket, to: Routes.customer_support_path(socket, :index))}
-    end
-  end
-
-  def render(assigns) do
-    ~H"""
-    <Layout.layout show_search={false} flash={@flash}>
-      <div class="overflow-hidden rounded-lg">
-        <.user_header user={@user} />
-        <.user_tab_navigation user={@user} tab={@tab} keys_count={@keys_count} />
-
-        <.live_component
-          module={tab_component(@tab)}
-          user={@user}
-          tab={@tab}
-          id={"user-#{@user.id}-#{@tab}"}
-        />
-      </div>
-    </Layout.layout>
-    """
-  end
-
-  defp user_header(assigns) do
-    ~H"""
-    <div class="sm:flex sm:items-center sm:justify-between">
-      <div class="sm:flex sm:space-x-5">
-        <div class="shrink-0">
-          <div class="rounded-full p-1 flex items-center justify-center">
-            <img
-              src={Plausible.Auth.User.profile_img_url(@user)}
-              class="w-14 rounded-full bg-gray-300"
-            />
-          </div>
-        </div>
-        <div class="mt-4 text-center sm:mt-0 sm:pt-1 sm:text-left">
-          <p class="text-xl font-bold sm:text-2xl">
-            <div class="flex items-center gap-x-2">
-              {@user.name}
-              <span :if={@user.type == :sso} class="bg-green-700 text-gray-100 text-xs p-1 rounded">
-                SSO
-              </span>
-            </div>
-          </p>
-          <p class="text-sm font-medium">{@user.email}</p>
-        </div>
-      </div>
-
-      <div class="mt-5 flex justify-center sm:mt-0">
-        <.input_with_clipboard
-          id="user-identifier"
-          name="user-identifier"
-          label="User Identifier"
-          value={@user.id}
-        />
-      </div>
-    </div>
-    """
-  end
-
-  defp user_tab_navigation(assigns) do
-    ~H"""
-    <.tab_navigation tab={@tab}>
-      <:tabs>
-        <.tab to="overview" tab={@tab}>Overview</.tab>
-        <.tab to="keys" tab={@tab}>
-          API Keys ({@keys_count})
-        </.tab>
-      </:tabs>
-    </.tab_navigation>
-    """
-  end
-
-  defp tab_component("overview"), do: Overview
-  defp tab_component("keys"), do: Keys
-  defp tab_component(_), do: Overview
-
-  defp count_keys(user) do
-    from(api_key in Plausible.Auth.ApiKey,
-      where: api_key.user_id == ^user.id
-    )
-    |> Repo.aggregate(:count)
-  end
-end

extra/lib/plausible_web/live/customer_support/user/components/keys.ex

@@ -1,52 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.User.Components.Keys do
-  @moduledoc """
-  User API keys component - handles displaying user's API keys
-  """
-  use PlausibleWeb, :live_component
-  import Ecto.Query
-  alias Plausible.Repo
-
-  def update(%{user: user}, socket) do
-    keys = keys(user)
-    {:ok, assign(socket, user: user, keys: keys)}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div class="mt-8">
-      <.table rows={@keys}>
-        <:thead>
-          <.th>Team</.th>
-          <.th>Name</.th>
-          <.th>Scopes</.th>
-          <.th>Prefix</.th>
-        </:thead>
-        <:tbody :let={api_key}>
-          <.td :if={is_nil(api_key.team)}>N/A</.td>
-          <.td :if={api_key.team}>
-            <.styled_link patch={
-              Routes.customer_support_team_path(PlausibleWeb.Endpoint, :show, api_key.team.id)
-            }>
-              {api_key.team.name}
-            </.styled_link>
-          </.td>
-          <.td>{api_key.name}</.td>
-          <.td>
-            {api_key.scopes}
-          </.td>
-          <.td>{api_key.key_prefix}</.td>
-        </:tbody>
-      </.table>
-    </div>
-    """
-  end
-
-  defp keys(user) do
-    from(
-      key in Plausible.Auth.ApiKey,
-      where: key.user_id == ^user.id,
-      preload: :team
-    )
-    |> Repo.all()
-  end
-end

extra/lib/plausible_web/live/customer_support/user/components/overview.ex

@@ -1,125 +0,0 @@
-defmodule PlausibleWeb.CustomerSupport.User.Components.Overview do
-  @moduledoc """
-  User overview component - handles user settings, team memberships, and user management
-  """
-  use PlausibleWeb, :live_component
-  import PlausibleWeb.CustomerSupport.Live
-
-  alias Plausible.Auth.TOTP
-
-  def update(%{user: user}, socket) do
-    form = user |> Plausible.Auth.User.changeset() |> to_form()
-    {:ok, assign(socket, user: user, form: form)}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div class="mt-8">
-      <div class="mb-8">
-        <div class="mt-4 flex items-center justify-between">
-          <div>
-            <span class="text-sm">
-              Two-Factor Authentication:
-              <span class={[
-                "text-sm font-medium",
-                if(TOTP.enabled?(@user), do: "text-green-600", else: "text-gray-500")
-              ]}>
-                {if TOTP.enabled?(@user), do: "Enabled", else: "Disabled"}
-              </span>
-            </span>
-          </div>
-        </div>
-      </div>
-
-      <.table rows={@user.team_memberships}>
-        <:thead>
-          <.th>Team</.th>
-          <.th>Role</.th>
-        </:thead>
-        <:tbody :let={membership}>
-          <.td>
-            <.styled_link patch={
-              Routes.customer_support_team_path(PlausibleWeb.Endpoint, :show, membership.team.id)
-            }>
-              {membership.team.name}
-            </.styled_link>
-          </.td>
-          <.td>{membership.role}</.td>
-        </:tbody>
-      </.table>
-
-      <.form :let={f} for={@form} phx-target={@myself} phx-submit="save-user" class="mt-8">
-        <.input type="textarea" field={f[:notes]} label="Notes" />
-        <div class="flex justify-between">
-          <div>
-            <.button phx-target={@myself} type="submit">
-              Save
-            </.button>
-          </div>
-          <div class="flex gap-2">
-            <.button
-              :if={TOTP.enabled?(@user)}
-              phx-target={@myself}
-              phx-click="force-disable-2fa"
-              data-confirm="Are you sure you want to force disable 2FA for this user? This action cannot be undone."
-              theme="danger"
-            >
-              Force Disable 2FA
-            </.button>
-            <.button
-              phx-target={@myself}
-              phx-click="delete-user"
-              data-confirm="Are you sure you want to delete this user?"
-              theme="danger"
-            >
-              Delete User
-            </.button>
-          </div>
-        </div>
-      </.form>
-    </div>
-    """
-  end
-
-  def handle_event("delete-user", _params, socket) do
-    user = socket.assigns.user
-
-    case Plausible.Auth.delete_user(user) do
-      {:ok, _} ->
-        navigate_with_success(Routes.customer_support_path(socket, :index), "User deleted")
-        {:noreply, socket}
-
-      {:error, :active_subscription} ->
-        failure("Cannot delete user with active subscription")
-        {:noreply, socket}
-
-      {:error, reason} ->
-        failure("Failed to delete user: #{inspect(reason)}")
-        {:noreply, socket}
-    end
-  end
-
-  def handle_event("force-disable-2fa", _params, socket) do
-    user = socket.assigns.user
-
-    {:ok, updated_user} = TOTP.force_disable(user)
-    send(self(), {:success, "2FA has been force disabled for this user"})
-    {:noreply, assign(socket, user: updated_user)}
-  end
-
-  def handle_event("save-user", %{"user" => params}, socket) do
-    user = socket.assigns.user
-
-    case Plausible.Auth.User.changeset(user, params) |> Plausible.Repo.update() do
-      {:ok, updated_user} ->
-        form = updated_user |> Plausible.Auth.User.changeset() |> to_form()
-        success("User updated successfully")
-        {:noreply, assign(socket, user: updated_user, form: form)}
-
-      {:error, changeset} ->
-        form = changeset |> to_form()
-        failure("Failed to update user")
-        {:noreply, assign(socket, form: form)}
-    end
-  end
-end

extra/lib/plausible_web/live/funnel_settings.ex

@@ -1,175 +0,0 @@
-defmodule PlausibleWeb.Live.FunnelSettings do
-  @moduledoc """
-  LiveView allowing listing, creating and deleting funnels.
-  """
-  use PlausibleWeb, :live_view
-
-  use Plausible.Funnel
-
-  alias Plausible.{Goals, Funnels, Teams}
-
-  def mount(
-        _params,
-        %{"site_id" => site_id, "domain" => domain},
-        socket
-      ) do
-    socket =
-      socket
-      |> assign_new(:site, fn %{current_user: current_user} ->
-        Plausible.Sites.get_for_user!(current_user, domain,
-          roles: [
-            :owner,
-            :admin,
-            :editor,
-            :super_admin
-          ]
-        )
-      end)
-      |> assign_new(:all_funnels, fn %{site: %{id: ^site_id} = site} ->
-        Funnels.list(site)
-      end)
-      |> assign_new(:goal_count, fn %{site: site} ->
-        Goals.count(site)
-      end)
-
-    {:ok,
-     assign(socket,
-       site_team: Teams.with_subscription(socket.assigns.site.team),
-       domain: domain,
-       displayed_funnels: socket.assigns.all_funnels,
-       setup_funnel?: false,
-       filter_text: "",
-       funnel_id: nil
-     )}
-  end
-
-  # Flash sharing with live views within dead views can be done via re-rendering the flash partial.
-  # Normally, we'd have to use live_patch which we can't do with views unmounted at the router it seems.
-  def render(assigns) do
-    ~H"""
-    <div id="funnel-settings-main">
-      <.flash_messages flash={@flash} />
-
-      <.tile
-        docs="funnel-analysis"
-        feature_mod={Plausible.Billing.Feature.Funnels}
-        feature_toggle?={true}
-        show_content?={!Plausible.Billing.Feature.Funnels.opted_out?(@site)}
-        site={@site}
-        current_user={@current_user}
-        current_team={@site_team}
-      >
-        <:title>
-          Funnels
-        </:title>
-        <:subtitle :if={Enum.count(@all_funnels) > 0}>
-          Compose goals into funnels to track user flows and conversion rates.
-        </:subtitle>
-        <%= if @setup_funnel? do %>
-          {live_render(
-            @socket,
-            PlausibleWeb.Live.FunnelSettings.Form,
-            id: "funnels-form",
-            session: %{
-              "domain" => @domain,
-              "funnel_id" => @funnel_id
-            }
-          )}
-        <% end %>
-        <div :if={@goal_count >= Funnel.min_steps()}>
-          <.live_component
-            module={PlausibleWeb.Live.FunnelSettings.List}
-            id="funnels-list"
-            funnels={@displayed_funnels}
-            filter_text={@filter_text}
-          />
-        </div>
-
-        <div
-          :if={@goal_count < Funnel.min_steps()}
-          class="flex flex-col items-center justify-center pt-5 pb-6 max-w-md mx-auto"
-        >
-          <h3 class="text-center text-base font-medium text-gray-900 dark:text-gray-100 leading-7">
-            Ready to dig into user flows?
-          </h3>
-          <p class="text-center text-sm mt-1 text-gray-500 dark:text-gray-400 leading-5 text-pretty">
-            Set up a few goals like <.highlighted>Signup</.highlighted>, <.highlighted>Visit /</.highlighted>, or
-            <.highlighted>Scroll 50% on /blog/*</.highlighted>
-            first, then return here to build your first funnel.
-          </p>
-          <.button_link
-            class="mt-4"
-            href={PlausibleWeb.Router.Helpers.site_path(@socket, :settings_goals, @domain)}
-          >
-            Set up goals →
-          </.button_link>
-        </div>
-      </.tile>
-    </div>
-    """
-  end
-
-  def handle_event("reset-filter-text", _params, socket) do
-    {:noreply, assign(socket, filter_text: "", displayed_funnels: socket.assigns.all_funnels)}
-  end
-
-  def handle_event("filter", %{"filter-text" => filter_text}, socket) do
-    new_list =
-      PlausibleWeb.Live.Components.ComboBox.StaticSearch.suggest(
-        filter_text,
-        socket.assigns.all_funnels,
-        to_string: & &1.name
-      )
-
-    {:noreply, assign(socket, displayed_funnels: new_list, filter_text: filter_text)}
-  end
-
-  def handle_event("add-funnel", _value, socket) do
-    {:noreply, assign(socket, setup_funnel?: true)}
-  end
-
-  def handle_event("edit-funnel", %{"funnel-id" => id}, socket) do
-    {:noreply, assign(socket, setup_funnel?: true, funnel_id: String.to_integer(id))}
-  end
-
-  def handle_event("delete-funnel", %{"funnel-id" => id}, socket) do
-    site =
-      Plausible.Sites.get_for_user!(
-        socket.assigns.current_user,
-        socket.assigns.domain,
-        roles: [:owner, :admin, :editor]
-      )
-
-    id = String.to_integer(id)
-    :ok = Funnels.delete(site, id)
-    socket = put_live_flash(socket, :success, "Funnel deleted successfully")
-
-    {:noreply,
-     assign(socket,
-       all_funnels: Enum.reject(socket.assigns.all_funnels, &(&1.id == id)),
-       displayed_funnels: Enum.reject(socket.assigns.displayed_funnels, &(&1.id == id))
-     )}
-  end
-
-  def handle_info({:funnel_saved, _funnel}, socket) do
-    socket = put_live_flash(socket, :success, "Funnel saved successfully")
-
-    funnels = Funnels.list(socket.assigns.site)
-
-    {:noreply,
-     assign(socket,
-       setup_funnel?: false,
-       all_funnels: funnels,
-       funnel_id: nil,
-       displayed_funnels: funnels
-     )}
-  end
-
-  def handle_info(:cancel_setup_funnel, socket) do
-    {:noreply, assign(socket, setup_funnel?: false, funnel_id: nil)}
-  end
-
-  def handle_info({:feature_toggled, flash_msg, updated_site}, socket) do
-    {:noreply, assign(put_flash(socket, :success, flash_msg), site: updated_site)}
-  end
-end

extra/lib/plausible_web/live/funnel_settings/form.ex

@@ -1,484 +0,0 @@
-defmodule PlausibleWeb.Live.FunnelSettings.Form do
-  @moduledoc """
-  Phoenix LiveComponent that renders a form used for setting up funnels.
-  Makes use of dynamically placed `PlausibleWeb.Live.FunnelSettings.ComboBox` components
-  to allow building searchable funnel definitions out of list of goals available.
-  """
-
-  use PlausibleWeb, :live_view
-  use Plausible.Funnel
-
-  import PlausibleWeb.Live.Components.Form
-  alias Plausible.{Goals, Funnels}
-  alias Plausible.Stats.QueryBuilder
-
-  def mount(_params, %{"domain" => domain} = session, socket) do
-    site =
-      Plausible.Sites.get_for_user!(socket.assigns.current_user, domain,
-        roles: [
-          :owner,
-          :admin,
-          :editor,
-          :super_admin
-        ]
-      )
-
-    # We'll have the options trimmed to only the data we care about, to keep
-    # it minimal at the socket assigns, yet, we want to retain specific %Goal{}
-    # fields, so that `String.Chars` protocol and `Funnels.ephemeral_definition/3`
-    # are applicable downstream.
-    goals =
-      site
-      |> Goals.for_site()
-      |> Enum.map(fn goal ->
-        {goal.id,
-         struct!(
-           Plausible.Goal,
-           Map.take(goal, [:id, :display_name, :event_name, :page_path, :currency])
-         )}
-      end)
-
-    socket =
-      socket
-      |> assign(goals: goals, site: site, evaluation_result: nil)
-      |> prepare_socket(site, session["funnel_id"])
-
-    {:ok, socket}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <div
-      class="fixed inset-0 bg-gray-500/75 transition-opacity z-50"
-      phx-window-keydown="cancel-add-funnel"
-      phx-key="Escape"
-    >
-    </div>
-    <div class="fixed inset-0 flex items-center justify-center mt-16 z-50 overlofw-y-auto overflow-x-hidden">
-      <div class="md:w-2/3 max-w-lg h-full">
-        <div id="funnel-form">
-          <.form
-            :let={f}
-            for={@form}
-            phx-change="validate"
-            phx-submit="save"
-            phx-target="#funnel-form"
-            phx-click-away="cancel-add-funnel"
-            onkeydown="return event.key != 'Enter';"
-            class="bg-white dark:bg-gray-900 shadow-2xl rounded-lg px-8 pt-6 pb-8 mb-4 mt-8"
-          >
-            <.title class="mb-6">
-              {if @funnel, do: "Edit", else: "Add"} funnel
-            </.title>
-
-            <.input
-              field={f[:name]}
-              phx-debounce={200}
-              autocomplete="off"
-              placeholder="e.g. From Blog to Purchase"
-              autofocus
-              label="Funnel name"
-            />
-
-            <div class="mt-6 flex items-center justify-between gap-4">
-              <span class="text-sm font-medium text-gray-900 dark:text-gray-100">
-                Allow other activity between funnel steps
-              </span>
-              <div class="flex items-center gap-3">
-                <.toggle_switch
-                  id="toggle-strict-order"
-                  id_suffix="switch"
-                  checked={!@strict_order?}
-                  phx-click="toggle-strict-order"
-                />
-              </div>
-            </div>
-
-            <div id="steps-builder" class="mt-6">
-              <.label>
-                Funnel steps
-              </.label>
-
-              <div :for={step_idx <- @step_ids} class="flex my-3">
-                <div class="w-2/5 flex-1">
-                  <.live_component
-                    selected={find_preselected(@funnel, @funnel_modified?, step_idx)}
-                    submit_name={"funnel[steps][#{step_idx}][goal_id]"}
-                    module={PlausibleWeb.Live.Components.ComboBox}
-                    suggest_fun={&PlausibleWeb.Live.Components.ComboBox.StaticSearch.suggest/2}
-                    on_selection_made={
-                      fn value, by_id ->
-                        send(self(), {:selection_made, %{submit_value: value, by: by_id}})
-                      end
-                    }
-                    id={"step-#{step_idx}"}
-                    options={reject_already_selected(@goals, @selections_made)}
-                  />
-                </div>
-
-                <div class="w-min inline-flex items-center align-middle">
-                  <.remove_step_button
-                    :if={length(@step_ids) > Funnel.min_steps()}
-                    step_idx={step_idx}
-                  />
-                </div>
-
-                <div class="w-4/12 mt-1 ml-4 text-gray-500 dark:text-gray-400">
-                  <.evaluation
-                    :if={@evaluation_result}
-                    result={@evaluation_result}
-                    at={Enum.find_index(@step_ids, &(&1 == step_idx))}
-                  />
-                </div>
-              </div>
-
-              <div class="flex flex-col gap-y-4 mt-6">
-                <.add_step_button :if={
-                  length(@step_ids) < Funnel.max_steps() and
-                    map_size(@selections_made) < length(@goals)
-                } />
-                <p id="funnel-eval" class="text-gray-800 dark:text-gray-200 text-sm">
-                  <%= if @evaluation_result do %>
-                    Last month conversion rate: <strong><%= List.last(@evaluation_result.steps).conversion_rate %></strong>%
-                  <% end %>
-                </p>
-              </div>
-
-              <.button
-                id="save"
-                type="submit"
-                class="w-full"
-                disabled={
-                  has_steps_errors?(f) or map_size(@selections_made) < Funnel.min_steps() or
-                    length(@step_ids) > map_size(@selections_made)
-                }
-              >
-                <span>{if @funnel, do: "Update", else: "Add"} funnel</span>
-              </.button>
-            </div>
-          </.form>
-        </div>
-      </div>
-    </div>
-    """
-  end
-
-  attr(:step_idx, :integer, required: true)
-
-  def remove_step_button(assigns) do
-    ~H"""
-    <div class="inline-flex items-center ml-2 text-red-500">
-      <svg
-        id={"remove-step-#{@step_idx}"}
-        class="feather feather-sm cursor-pointer"
-        xmlns="http://www.w3.org/2000/svg"
-        viewBox="0 0 24 24"
-        fill="none"
-        stroke="currentColor"
-        stroke-width="2"
-        stroke-linecap="round"
-        stroke-linejoin="round"
-        phx-click="remove-step"
-        phx-value-step-idx={@step_idx}
-      >
-        <polyline points="3 6 5 6 21 6"></polyline>
-        <path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2">
-        </path>
-        <line x1="10" y1="11" x2="10" y2="17"></line>
-        <line x1="14" y1="11" x2="14" y2="17"></line>
-      </svg>
-    </div>
-    """
-  end
-
-  def add_step_button(assigns) do
-    ~H"""
-    <a class="text-indigo-500 text-sm font-medium cursor-pointer" phx-click="add-step">
-      + Add another step
-    </a>
-    """
-  end
-
-  attr(:at, :integer, required: true)
-  attr(:result, :map, required: true)
-
-  def evaluation(assigns) do
-    ~H"""
-    <span class="text-sm" id={"step-eval-#{@at}"}>
-      <% step = Enum.at(@result.steps, @at) %>
-      <span :if={step && @at == 0}>
-        <span
-          class="border-dotted border-b border-gray-400 "
-          tooltip="Sample calculation for last month"
-        >
-          <span class="hidden md:inline">Visitors: </span><strong><%= PlausibleWeb.StatsView.large_number_format(@result.entering_visitors) %></strong>
-        </span>
-      </span>
-      <span :if={step && @at > 0}>
-        <span class="hidden md:inline">Dropoff: </span><strong><%= Map.get(step, :dropoff_percentage) %>%</strong>
-      </span>
-    </span>
-    """
-  end
-
-  def handle_event("add-step", _value, socket) do
-    step_ids = socket.assigns.step_ids
-
-    socket = assign(socket, funnel_modified?: true)
-
-    if length(step_ids) < Funnel.max_steps() do
-      first_free_idx = find_sequence_break(step_ids)
-      new_ids = step_ids ++ [first_free_idx]
-      {:noreply, assign(socket, step_ids: new_ids)}
-    else
-      {:noreply, socket}
-    end
-  end
-
-  def handle_event("remove-step", %{"step-idx" => idx}, socket) do
-    idx = String.to_integer(idx)
-    step_ids = List.delete(socket.assigns.step_ids, idx)
-    selections_made = drop_selection(socket.assigns.selections_made, idx)
-
-    send(self(), :evaluate_funnel)
-
-    {:noreply,
-     assign(socket, step_ids: step_ids, selections_made: selections_made, funnel_modified?: true)}
-  end
-
-  def handle_event("toggle-strict-order", _params, socket) do
-    strict_order? = !socket.assigns.strict_order?
-    send(self(), :evaluate_funnel)
-
-    {:noreply, assign(socket, strict_order?: strict_order?)}
-  end
-
-  def handle_event("validate", %{"funnel" => params}, socket) do
-    strict_order? = socket.assigns.strict_order?
-
-    steps_from_assigns =
-      socket.assigns.step_ids
-      |> Enum.reduce([], fn step_id, acc ->
-        goal = Map.get(socket.assigns.selections_made, "step-#{step_id}")
-        if goal, do: [%{"goal_id" => goal.id} | acc], else: acc
-      end)
-      |> Enum.reverse()
-
-    changeset =
-      socket.assigns.site
-      |> Funnels.create_changeset(
-        params["name"],
-        steps_from_assigns,
-        strict_order?: strict_order?
-      )
-      |> Map.put(:action, :validate)
-
-    {:noreply, assign(socket, form: to_form(changeset))}
-  end
-
-  def handle_event(
-        "save",
-        %{"funnel" => params},
-        %{assigns: %{site: site, funnel: funnel, strict_order?: strict_order?}} = socket
-      ) do
-    steps = Enum.map(params["steps"], fn {_idx, payload} -> payload end)
-
-    save_fn =
-      case funnel do
-        %Plausible.Funnel{} ->
-          fn -> Funnels.update(funnel, params["name"], steps, strict_order?: strict_order?) end
-
-        nil ->
-          fn -> Funnels.create(site, params["name"], steps, strict_order?: strict_order?) end
-      end
-
-    case save_fn.() do
-      {:ok, funnel} ->
-        send(
-          socket.parent_pid,
-          {:funnel_saved, Map.put(funnel, :steps_count, length(steps))}
-        )
-
-        {:noreply, socket}
-
-      {:error, changeset} ->
-        {:noreply,
-         assign(socket,
-           form: to_form(Map.put(changeset, :action, :validate))
-         )}
-    end
-  end
-
-  def handle_event("cancel-add-funnel", _value, socket) do
-    send(socket.parent_pid, :cancel_setup_funnel)
-    {:noreply, socket}
-  end
-
-  def handle_info({:selection_made, %{submit_value: goal_id, by: combo_box}}, socket) do
-    selections_made = store_selection(socket.assigns, combo_box, goal_id)
-
-    send(self(), :evaluate_funnel)
-
-    {:noreply,
-     assign(socket,
-       selections_made: selections_made
-     )}
-  end
-
-  def handle_info(:evaluate_funnel, socket) do
-    {:noreply, evaluate_funnel(socket)}
-  end
-
-  defp evaluate_funnel(%{assigns: %{selections_made: selections_made}} = socket)
-       when map_size(selections_made) < Funnel.min_steps() do
-    socket
-  end
-
-  defp evaluate_funnel(
-         %{
-           assigns: %{
-             site: site,
-             selections_made: selections_made,
-             strict_order?: strict_order?
-           }
-         } = socket
-       ) do
-    with {:ok, {definition, query}} <-
-           build_ephemeral_funnel(site, selections_made, strict_order?: strict_order?),
-         {:ok, funnel} <- Plausible.Stats.funnel(site, query, definition) do
-      assign(socket, evaluation_result: funnel)
-    else
-      _ ->
-        socket
-    end
-  end
-
-  defp build_ephemeral_funnel(site, selections_made, opts) do
-    steps =
-      selections_made
-      |> Enum.sort_by(&elem(&1, 0))
-      |> Enum.map(fn {_, goal} ->
-        %{
-          "goal_id" => goal.id,
-          "goal" => %{
-            "id" => goal.id,
-            "event_name" => goal.event_name,
-            "page_path" => goal.page_path
-          }
-        }
-      end)
-
-    definition =
-      Funnels.ephemeral_definition(
-        site,
-        "Test funnel",
-        steps,
-        opts
-      )
-
-    query =
-      QueryBuilder.build!(site,
-        metrics: [:pageviews],
-        input_date_range: :month
-      )
-
-    {:ok, {definition, query}}
-  end
-
-  defp find_sequence_break(input) do
-    input
-    |> Enum.sort()
-    |> Enum.with_index(1)
-    |> Enum.reduce_while(nil, fn {x, order}, _ ->
-      if x != order do
-        {:halt, order}
-      else
-        {:cont, order + 1}
-      end
-    end)
-  end
-
-  defp has_steps_errors?(f) do
-    not f.source.valid?
-  end
-
-  defp get_goal(assigns, id) do
-    assigns
-    |> Map.fetch!(:goals)
-    |> Enum.find_value(fn
-      {goal_id, goal} when goal_id == id -> goal
-      _ -> nil
-    end)
-  end
-
-  defp store_selection(assigns, combo_box, goal_id) do
-    Map.put(assigns.selections_made, combo_box, get_goal(assigns, goal_id))
-  end
-
-  defp drop_selection(selections_made, step_idx) do
-    step_input_id = "step-#{step_idx}"
-    Map.delete(selections_made, step_input_id)
-  end
-
-  defp reject_already_selected(goals, selections_made) do
-    selection_ids =
-      Enum.map(selections_made, fn
-        {_, %{id: goal_id}} -> goal_id
-      end)
-
-    Enum.reject(goals, fn {goal_id, _} -> goal_id in selection_ids end)
-  end
-
-  defp find_preselected(%Funnel{} = funnel, false, idx) do
-    if step = Enum.at(funnel.steps, idx - 1) do
-      {step.goal.id, to_string(step.goal)}
-    end
-  end
-
-  defp find_preselected(_, _, _), do: nil
-
-  defp prepare_socket(socket, site, funnel_id) when is_integer(funnel_id) do
-    funnel = Funnels.get(site.id, funnel_id)
-
-    form =
-      funnel
-      |> Funnels.edit_changeset(
-        funnel.name,
-        Enum.map(funnel.steps, &%{goal_id: &1.goal.id}),
-        strict_order?: funnel.strict_order
-      )
-      |> to_form()
-
-    selections_made =
-      Enum.reduce(Enum.with_index(funnel.steps, 1), %{}, fn {step, idx}, acc ->
-        Map.put(acc, "step-#{idx}", step.goal)
-      end)
-
-    socket =
-      assign(
-        socket,
-        form: form,
-        funnel: funnel,
-        strict_order?: funnel.strict_order,
-        funnel_modified?: false,
-        selections_made: selections_made,
-        step_ids: Enum.to_list(1..Enum.count(funnel.steps))
-      )
-
-    evaluate_funnel(socket)
-  end
-
-  defp prepare_socket(socket, site, nil) do
-    form = to_form(Funnels.create_changeset(site, "", []))
-
-    assign(
-      socket,
-      form: form,
-      funnel: nil,
-      strict_order?: false,
-      funnel_modified?: false,
-      selections_made: Map.new(),
-      step_ids: Enum.to_list(1..Funnel.min_steps())
-    )
-  end
-end

extra/lib/plausible_web/live/funnel_settings/list.ex

@@ -1,89 +0,0 @@
-defmodule PlausibleWeb.Live.FunnelSettings.List do
-  @moduledoc """
-  Phoenix LiveComponent module that renders a list of funnels with their names
-  and the number of steps they have.
-
-  Each funnel is displayed with a delete button, which triggers a confirmation
-  message before deleting the funnel from the UI. If there are no funnels
-  configured for the site, a message is displayed indicating so.
-  """
-  use PlausibleWeb, :live_component
-
-  def render(assigns) do
-    assigns = assign(assigns, :searching?, String.trim(assigns.filter_text) != "")
-
-    ~H"""
-    <div class="flex flex-col gap-4 sm:gap-6">
-      <%= if @searching? or Enum.count(@funnels) > 0 do %>
-        <.filter_bar filter_text={@filter_text} placeholder="Search Funnels">
-          <.button id="add-funnel-button" phx-click="add-funnel" mt?={false}>
-            Add funnel
-          </.button>
-        </.filter_bar>
-      <% end %>
-
-      <%= if Enum.count(@funnels) > 0 do %>
-        <.table rows={@funnels}>
-          <:tbody :let={funnel}>
-            <.td truncate>
-              <span class="font-medium">{funnel.name}</span>
-            </.td>
-            <.td hide_on_mobile>
-              <span class="text-gray-500 dark:text-gray-400">
-                {funnel.steps_count}-step funnel
-              </span>
-            </.td>
-            <.td actions>
-              <.edit_button phx-click="edit-funnel" phx-value-funnel-id={funnel.id} />
-              <.delete_button
-                id={"delete-funnel-#{funnel.id}"}
-                phx-click="delete-funnel"
-                phx-value-funnel-id={funnel.id}
-                class="text-sm text-red-600"
-                data-confirm={"Are you sure you want to remove funnel '#{funnel.name}'? This will just affect the UI, all of your analytics data will stay intact."}
-              />
-            </.td>
-          </:tbody>
-        </.table>
-      <% else %>
-        <.no_search_results :if={@searching?} />
-        <.empty_state :if={not @searching?} />
-      <% end %>
-    </div>
-    """
-  end
-
-  defp no_search_results(assigns) do
-    ~H"""
-    <p class="mt-12 mb-8 text-sm text-center">
-      No funnels found for this site. Please refine or
-      <.styled_link phx-click="reset-filter-text" id="reset-filter-hint">
-        reset your search.
-      </.styled_link>
-    </p>
-    """
-  end
-
-  defp empty_state(assigns) do
-    ~H"""
-    <div class="flex flex-col items-center justify-center pt-5 pb-6 max-w-md mx-auto">
-      <h3 class="text-center text-base font-medium text-gray-900 dark:text-gray-100 leading-7">
-        Create your first funnel
-      </h3>
-      <p class="text-center text-sm mt-1 text-gray-500 dark:text-gray-400 leading-5 text-pretty">
-        Compose goals into funnels to track user flows and conversion rates.
-        <.styled_link href="https://plausible.io/docs/funnel-analysis" target="_blank">
-          Learn more
-        </.styled_link>
-      </p>
-      <.button
-        id="add-funnel-button"
-        phx-click="add-funnel"
-        class="mt-4"
-      >
-        Add funnel
-      </.button>
-    </div>
-    """
-  end
-end

extra/lib/plausible_web/live/sso_management.ex

@@ -1,740 +0,0 @@
-defmodule PlausibleWeb.Live.SSOManagement do
-  @moduledoc """
-  Live view for SSO setup and management.
-  """
-  use PlausibleWeb, :live_view
-
-  alias Plausible.Auth.SSO
-  alias Plausible.Teams
-
-  alias PlausibleWeb.Router.Helpers, as: Routes
-  use Plausible.Auth.SSO.Domain.Status
-
-  @refresh_integration_interval :timer.seconds(5)
-
-  def mount(_params, _session, socket) do
-    socket = load_integration(socket, socket.assigns.current_team)
-
-    if connected?(socket) do
-      Process.send_after(self(), :refresh_integration, @refresh_integration_interval)
-    end
-
-    {:ok, route_mode(socket)}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <.flash_messages flash={@flash} />
-
-    <.tile
-      :if={@mode != :manage}
-      docs={if @mode in [:domain_setup, :domain_verify], do: "sso#sso-domains", else: "sso"}
-    >
-      <:title>
-        <a id="sso-config">Single Sign-On</a>
-      </:title>
-      <:subtitle>
-        Configure and manage Single Sign-On for your team.
-      </:subtitle>
-
-      <.init_view :if={@mode == :init} current_team={@current_team} />
-
-      <.init_setup_view
-        :if={@mode == :init_setup}
-        integration={@integration}
-        current_team={@current_team}
-      />
-
-      <.idp_form_view
-        :if={@mode == :idp_form}
-        integration={@integration}
-        config_changeset={@config_changeset}
-      />
-
-      <.domain_setup_view
-        :if={@mode == :domain_setup}
-        integration={@integration}
-        domain_changeset={@domain_changeset}
-      />
-
-      <.domain_verify_view :if={@mode == :domain_verify} domain={@domain} />
-    </.tile>
-
-    <.manage_view
-      :if={@mode == :manage}
-      integration={@integration}
-      current_team={@current_team}
-      can_toggle_force_sso?={@can_toggle_force_sso?}
-      force_sso_warning={@force_sso_warning}
-      policy_changeset={@policy_changeset}
-      role_options={@role_options}
-      domain_delete_checks={@domain_delete_checks}
-    />
-    """
-  end
-
-  def init_view(assigns) do
-    ~H"""
-    <form id="sso-init" for={} phx-submit="init-sso">
-      <p class="text-sm">
-        Single Sign-On (SSO) enables team members to sign in without having to register an account. For more details, <.styled_link href="https://plausible.io/docs/sso">see our documentation</.styled_link>.
-      </p>
-
-      <.button type="submit">Start Configuring SSO</.button>
-    </form>
-    """
-  end
-
-  def init_setup_view(assigns) do
-    ~H"""
-    <div class="flex-col space-y-6">
-      <p class="text-sm">
-        Use the following parameters when configuring your Identity Provider of choice:
-      </p>
-
-      <.input_with_clipboard
-        id="sp-acs-url"
-        name="sp-acs-url"
-        label="ACS URL / Single Sign-On URL / Reply URL"
-        value={saml_acs_url(@integration)}
-      />
-
-      <.form id="sso-sp-config" for={} class="flex-col space-y-4">
-        <.input_with_clipboard
-          id="sp-entity-id"
-          name="sp-entity-id"
-          label="Entity ID / Audience URI / Identifier"
-          value={SSO.SAMLConfig.entity_id(@integration)}
-        />
-      </.form>
-
-      <div class="flex-col space-y-3">
-        <p class="text-sm">Following attribute mappings must be set up at Identity Provider:</p>
-
-        <ul role="list" class="list-disc leading-6 text-sm ml-8">
-          <li :for={param <- ["email", "first_name", "last_name"]}>
-            <code>{param}</code>
-          </li>
-        </ul>
-      </div>
-
-      <form id="sso-idp-form" for={} phx-submit="show-idp-form">
-        <p class="text-sm">Click below to start setting up Single Sign-On for your team.</p>
-
-        <.button type="submit">Start Configuring</.button>
-      </form>
-    </div>
-    """
-  end
-
-  def idp_form_view(assigns) do
-    ~H"""
-    <div class="flex-col space-y-6">
-      <p class="text-sm">
-        Enter configuration details of Identity Provider after configuring it:
-      </p>
-
-      <.form
-        :let={f}
-        id="sso-idp-config"
-        for={@config_changeset}
-        class="flex-col space-y-4"
-        phx-submit="update-integration"
-      >
-        <.input
-          field={f[:idp_signin_url]}
-          label="SSO URL / Sign-on URL / Login URL"
-          placeholder="<URL>"
-        />
-
-        <.input
-          field={f[:idp_entity_id]}
-          label="Entity ID / Issuer / Identifier"
-          placeholder="<Entity ID>"
-        />
-
-        <.input field={f[:idp_cert_pem]} type="textarea" label="Signing Certificate in PEM format" />
-
-        <.button type="submit">Save</.button>
-      </.form>
-    </div>
-    """
-  end
-
-  def domain_setup_view(assigns) do
-    ~H"""
-    <div class="flex-col space-y-6">
-      <p class="text-sm">
-        In order for Single Sign-On to work, you have to allow at least one email address domain:
-      </p>
-
-      <.form
-        :let={f}
-        id="sso-add-domain"
-        for={@domain_changeset}
-        class="flex-col space-y-4"
-        phx-submit="add-domain"
-      >
-        <.input field={f[:domain]} label="Domain" placeholder="example.com" />
-
-        <.button type="submit">Add Domain</.button>
-      </.form>
-    </div>
-    """
-  end
-
-  def domain_verify_view(assigns) do
-    ~H"""
-    <div class="flex-col space-y-6">
-      <p class="text-sm">Verifying domain {@domain.domain}</p>
-
-      <p class="text-sm">You can verify ownership of the domain using one of 3 methods:</p>
-
-      <ul class="list-disc ml-4 space-y-6">
-        <li>
-          <.input_with_clipboard
-            name="verification-dns-txt"
-            label={"Add a TXT record to #{@domain.domain} domain with the following value"}
-            id="verification-dns-txt"
-            value={"plausible-sso-verification=#{@domain.identifier}"}
-          />
-        </li>
-        <li>
-          <.input_with_clipboard
-            name="verification-url"
-            label={"Publish a file or route at https://#{@domain.domain}/plausible-sso-verification rendering the following contents"}
-            id="verification-url"
-            value={@domain.identifier}
-          />
-        </li>
-        <li>
-          <.input_with_clipboard
-            name="verification-meta-tag"
-            label={"Add a following META tag to the web page at https://#{@domain.domain}"}
-            id="verification-meta-tag"
-            value={~s|<meta name="plausible-sso-verification" content="#{@domain.identifier}">|}
-          />
-        </li>
-      </ul>
-
-      <.notice>
-        We'll keep checking your domain ownership. Once any of the above verification methods succeeds, we'll send you an e-mail. Thank you for your patience.
-      </.notice>
-
-      <form id="verify-domain-submit" for={} phx-submit="verify-domain-submit">
-        <.input type="hidden" name="identifier" value={@domain.identifier} />
-        <.button
-          :if={@domain.status in [Status.in_progress(), Status.unverified(), Status.verified()]}
-          type="submit"
-        >
-          Run Verification Now
-        </.button>
-
-        <.button :if={@domain.status == Status.pending()} type="submit">Continue</.button>
-      </form>
-    </div>
-    """
-  end
-
-  def manage_view(assigns) do
-    ~H"""
-    <.tile docs="sso">
-      <:title>
-        <a id="sso-manage-config">Single Sign-On</a>
-      </:title>
-      <:subtitle>
-        Configure and manage Single Sign-On for your team.
-      </:subtitle>
-
-      <div class="flex-col space-y-6">
-        <p class="text-sm">
-          Use the following parameters when configuring your Identity Provider of choice:
-        </p>
-
-        <form id="sso-sp-config" for={} class="flex-col space-y-4">
-          <.input_with_clipboard
-            id="sp-acs-url"
-            name="sp-acs-url"
-            label="ACS URL / Single Sign-On URL / Reply URL"
-            value={saml_acs_url(@integration)}
-          />
-
-          <.input_with_clipboard
-            id="sp-entity-id"
-            name="sp-entity-id"
-            label="Entity ID / Audience URI / Identifier"
-            value={SSO.SAMLConfig.entity_id(@integration)}
-          />
-        </form>
-
-        <div class="flex-col space-y-3">
-          <p class="text-sm">Following attribute mappings must be setup at Identity Provider:</p>
-
-          <ul role="list" class="list-disc leading-6 text-sm ml-8">
-            <li :for={param <- ["email", "first_name", "last_name"]}>
-              <code>{param}</code>
-            </li>
-          </ul>
-        </div>
-
-        <div class="flex-col space-y-3">
-          <p class="text-sm">
-            Current Identity Provider configuration:
-          </p>
-
-          <.form :let={f} id="sso-idp-config" for={} class="flex-col space-y-4">
-            <.input
-              field={f[:idp_signin_url]}
-              value={@integration.config.idp_signin_url}
-              label="SSO URL / Sign-on URL / Login URL"
-              readonly={true}
-            />
-
-            <.input
-              field={f[:idp_entity_id]}
-              value={@integration.config.idp_entity_id}
-              label="Entity ID / Issuer / Identifier"
-              readonly={true}
-            />
-
-            <.input
-              field={f[:idp_cert_pem]}
-              type="textarea"
-              label="Signing Certificate in PEM format"
-              value={@integration.config.idp_cert_pem}
-              readonly={true}
-            />
-          </.form>
-
-          <form id="show-idp-form" for={} phx-submit="show-idp-form">
-            <.button type="submit">Edit</.button>
-          </form>
-        </div>
-      </div>
-    </.tile>
-
-    <.tile docs="sso#sso-domains">
-      <:title>
-        <a id="sso-domains-config">SSO Domains</a>
-      </:title>
-      <:subtitle>
-        Email domains accepted from Identity Provider
-      </:subtitle>
-      <div class="flex-col space-y-3">
-        <.table rows={@integration.sso_domains}>
-          <:thead>
-            <.th>Domain</.th>
-            <.th hide_on_mobile>Added at</.th>
-            <.th>Status</.th>
-            <.th invisible>Actions</.th>
-          </:thead>
-          <:tbody :let={domain}>
-            <.td>{domain.domain}</.td>
-            <.td hide_on_mobile>
-              {Calendar.strftime(domain.inserted_at, "%b %-d, %Y at %H:%m UTC")}
-            </.td>
-            <.td :if={domain.status != Status.in_progress()}>{domain.status}</.td>
-            <.td :if={domain.status == Status.in_progress()}>
-              <div class="flex items-center gap-x-2">
-                <.spinner class="w-4 h-4" />
-                <.styled_link
-                  id={"cancel-verify-domain-#{domain.identifier}"}
-                  phx-click="cancel-verify-domain"
-                  phx-value-identifier={domain.identifier}
-                >
-                  Cancel
-                </.styled_link>
-              </div>
-            </.td>
-            <.td actions>
-              <.styled_link
-                :if={domain.status not in [Status.in_progress(), Status.verified()]}
-                id={"verify-domain-#{domain.identifier}"}
-                phx-click="verify-domain"
-                phx-value-identifier={domain.identifier}
-              >
-                Verify
-              </.styled_link>
-
-              <.delete_button
-                :if={is_nil(@domain_delete_checks[domain.identifier])}
-                id={"remove-domain-#{domain.identifier}"}
-                phx-click="remove-domain"
-                phx-value-identifier={domain.identifier}
-                class="text-sm text-red-600"
-                data-confirm={"Are you sure you want to remove domain '#{domain.domain}'?"}
-              />
-
-              <.delete_button
-                :if={@domain_delete_checks[domain.identifier]}
-                id={"disabled-remove-domain-#{domain.identifier}"}
-                class="text-sm text-red-600"
-                data-confirm={"You cannot delete this domain. #{@domain_delete_checks[domain.identifier]}"}
-              />
-            </.td>
-          </:tbody>
-        </.table>
-
-        <form id="show-domain-setup" for={} phx-submit="show-domain-setup">
-          <.button type="submit">Add Domain</.button>
-        </form>
-      </div>
-    </.tile>
-
-    <.tile docs="sso#sso-policy">
-      <:title>
-        <a id="sso-policy-config">SSO Policy</a>
-      </:title>
-      <:subtitle>
-        Adjust your SSO policy configuration
-      </:subtitle>
-      <div
-        x-data={Jason.encode!(%{active: @current_team.policy.force_sso == :all_but_owners})}
-        class="flex-col space-y-3"
-      >
-        <p class="text-sm">Enforce Single Sign-On for the whole team, except Owners:</p>
-
-        <.tooltip enabled?={not @can_toggle_force_sso?}>
-          <:tooltip_content>
-            <div class="text-xs">
-              To get access to this feature, {@force_sso_warning}.
-            </div>
-          </:tooltip_content>
-          <div class="flex itemx-center mb-3">
-            <PlausibleWeb.Components.Generic.toggle_switch
-              id="enable-force-sso"
-              id_suffix="toggle"
-              js_active_var="active"
-              disabled={not @can_toggle_force_sso?}
-              phx-click="toggle-force-sso"
-            />
-            <span class={[
-              "ml-3 text-sm font-medium",
-              if(@can_toggle_force_sso?,
-                do: "text-gray-900 dark:text-gray-100",
-                else: "text-gray-500 dark:text-gray-400"
-              )
-            ]}>
-              Force Single Sign-On
-            </span>
-          </div>
-        </.tooltip>
-      </div>
-
-      <div class="flex-col space-y-3">
-        <.form
-          :let={f}
-          id="sso-policy"
-          for={@policy_changeset}
-          class="flex-col space-y-4"
-          phx-submit="update-policy"
-        >
-          <.input
-            field={f[:sso_default_role]}
-            label="Default role"
-            type="select"
-            options={@role_options}
-          />
-
-          <.input
-            field={f[:sso_session_timeout_minutes]}
-            label="Session timeout (minutes)"
-            type="number"
-          />
-
-          <.button type="submit">Update</.button>
-        </.form>
-      </div>
-    </.tile>
-    """
-  end
-
-  def handle_event("init-sso", _params, socket) do
-    team = socket.assigns.current_team
-    integration = SSO.initiate_saml_integration(team)
-
-    socket =
-      socket
-      |> assign(:integration, integration)
-      |> load_integration(team)
-      |> route_mode()
-
-    {:noreply, socket}
-  end
-
-  def handle_event("show-idp-form", _params, socket) do
-    {:noreply, route_mode(socket, :idp_form)}
-  end
-
-  def handle_event("update-integration", params, socket) do
-    socket =
-      case SSO.update_integration(socket.assigns.integration, params["saml_config"] || %{}) do
-        {:ok, integration} ->
-          socket
-          |> assign(:integration, integration)
-          |> load_integration(socket.assigns.current_team)
-          |> route_mode()
-
-        {:error, changeset} ->
-          assign(socket, :config_changeset, changeset)
-      end
-
-    {:noreply, socket}
-  end
-
-  def handle_event("add-domain", params, socket) do
-    integration = socket.assigns.integration
-
-    socket =
-      case SSO.Domains.add(integration, params["domain"]["domain"] || "") do
-        {:ok, sso_domain} ->
-          socket
-          |> load_integration(socket.assigns.current_team)
-          |> assign(:domain, sso_domain)
-          |> route_mode(:domain_verify)
-
-        {:error, changeset} ->
-          socket
-          |> assign(:domain_changeset, changeset)
-      end
-
-    {:noreply, socket}
-  end
-
-  def handle_event("verify-domain-submit", params, socket) do
-    integration = socket.assigns.integration
-    sso_domain = Enum.find(integration.sso_domains, &(&1.identifier == params["identifier"]))
-
-    if sso_domain do
-      SSO.Domains.start_verification(sso_domain.domain)
-      {:noreply, route_mode(load_integration(socket, socket.assigns.current_team), :manage)}
-    else
-      {:noreply, socket}
-    end
-  end
-
-  def handle_event("show-domain-setup", _params, socket) do
-    {:noreply, route_mode(socket, :domain_setup)}
-  end
-
-  def handle_event("verify-domain", params, socket) do
-    integration = socket.assigns.integration
-    domain = Enum.find(integration.sso_domains, &(&1.identifier == params["identifier"]))
-
-    if domain do
-      socket =
-        socket
-        |> load_integration(socket.assigns.current_team)
-        |> assign(:domain, domain)
-        |> route_mode(:domain_verify)
-
-      {:noreply, socket}
-    else
-      {:noreply, route_mode(socket, :manage)}
-    end
-  end
-
-  def handle_event("cancel-verify-domain", params, socket) do
-    integration = socket.assigns.integration
-    domain = Enum.find(integration.sso_domains, &(&1.identifier == params["identifier"]))
-
-    socket =
-      if domain do
-        :ok = SSO.Domains.cancel_verification(domain.domain)
-        load_integration(socket, socket.assigns.current_team)
-      else
-        socket
-      end
-
-    {:noreply, socket}
-  end
-
-  def handle_event("remove-domain", params, socket) do
-    integration = socket.assigns.integration
-    domain = Enum.find(integration.sso_domains, &(&1.identifier == params["identifier"]))
-
-    if domain do
-      socket =
-        case SSO.Domains.remove(domain) do
-          :ok ->
-            socket
-            |> load_integration(socket.assigns.current_team)
-            |> route_mode()
-
-          {:error, :force_sso_enabled} ->
-            socket
-
-          {:error, :sso_users_present} ->
-            socket
-        end
-
-      {:noreply, socket}
-    else
-      {:noreply, route_mode(socket, :manage)}
-    end
-  end
-
-  def handle_event("toggle-force-sso", _params, socket) do
-    team = socket.assigns.current_team
-    new_toggle = if team.policy.force_sso == :none, do: :all_but_owners, else: :none
-
-    case SSO.set_force_sso(socket.assigns.current_team, new_toggle) do
-      {:ok, team} ->
-        socket =
-          socket
-          |> assign(:current_team, team)
-
-        {:noreply, socket}
-
-      {:error, _} ->
-        {:noreply, route_mode(socket, :manage)}
-    end
-  end
-
-  def handle_event("update-policy", params, socket) do
-    team = socket.assigns.current_team
-    params = params["policy"]
-
-    attrs = [
-      sso_default_role: params["sso_default_role"],
-      sso_session_timeout_minutes: params["sso_session_timeout_minutes"]
-    ]
-
-    socket =
-      case SSO.update_policy(team, attrs) do
-        {:ok, team} ->
-          policy_changeset = Teams.Policy.update_changeset(team.policy, %{})
-
-          socket
-          |> assign(:current_team, team)
-          |> assign(:policy_changeset, policy_changeset)
-
-        {:error, changeset} ->
-          socket
-          |> assign(:policy_changeset, changeset)
-      end
-
-    {:noreply, socket}
-  end
-
-  def handle_info(:refresh_integration, socket) do
-    Process.send_after(self(), :refresh_integration, @refresh_integration_interval)
-    {:noreply, load_integration(socket, socket.assigns.current_team)}
-  end
-
-  defp load_integration(socket, team) do
-    integration =
-      case SSO.get_integration_for(team) do
-        {:ok, integration} -> integration
-        {:error, :not_found} -> nil
-      end
-
-    assign(socket, :integration, integration)
-  end
-
-  defp route_mode(socket, force_mode \\ nil) do
-    integration = socket.assigns.integration
-
-    mode =
-      cond do
-        force_mode ->
-          force_mode
-
-        is_nil(integration) ->
-          :init
-
-        not SSO.Integration.configured?(integration) ->
-          :init_setup
-
-        integration.sso_domains == [] ->
-          :domain_setup
-
-        true ->
-          :manage
-      end
-
-    socket
-    |> assign(:mode, mode)
-    |> load(mode)
-  end
-
-  defp load(socket, :idp_form) do
-    assign(
-      socket,
-      :config_changeset,
-      SSO.SAMLConfig.changeset(socket.assigns.integration.config, %{})
-    )
-  end
-
-  defp load(socket, :domain_setup) do
-    assign(socket, :domain_changeset, SSO.Domain.create_changeset(socket.assigns.integration, ""))
-  end
-
-  defp load(socket, :manage) do
-    team = socket.assigns.current_team
-    toggle_mode = if team.policy.force_sso == :none, do: :all_but_owners, else: :none
-
-    {can_toggle_force_sso?, toggle_disabled_reason} =
-      case {SSO.check_force_sso(team, toggle_mode), socket.assigns.current_user.type} do
-        {:ok, :sso} ->
-          {true, nil}
-
-        {:ok, :standard} ->
-          {false, "you must be logged in via SSO"}
-
-        {{:error, :no_integration}, _} ->
-          {false, "you must first setup Single Sign-On"}
-
-        {{:error, :no_domain}, _} ->
-          {false, "you must add a domain"}
-
-        {{:error, :no_verified_domain}, _} ->
-          {false, "you must verify a domain"}
-
-        {{:error, :owner_2fa_disabled}, _} ->
-          {false, "all Owners must have 2FA enabled"}
-
-        {{:error, :no_sso_user}, _} ->
-          {false, "at least one SSO user must log in successfully"}
-      end
-
-    policy_changeset = Teams.Policy.update_changeset(team.policy, %{})
-
-    role_options =
-      Enum.map(Teams.Policy.sso_member_roles(), fn role ->
-        {String.capitalize(to_string(role)), role}
-      end)
-      |> Enum.sort()
-
-    domain_delete_checks =
-      Enum.into(socket.assigns.integration.sso_domains, %{}, fn domain ->
-        prevent_delete_reason =
-          case Plausible.Auth.SSO.Domains.check_can_remove(domain) do
-            :ok -> nil
-            {:error, :force_sso_enabled} -> "You must disable 'Force SSO' first."
-            {:error, :sso_users_present} -> "There are existing SSO accounts on this domain."
-          end
-
-        {domain.identifier, prevent_delete_reason}
-      end)
-
-    socket
-    |> assign(:domain_delete_checks, domain_delete_checks)
-    |> assign(:can_toggle_force_sso?, can_toggle_force_sso?)
-    |> assign(:force_sso_warning, toggle_disabled_reason)
-    |> assign(:policy_changeset, policy_changeset)
-    |> assign(:role_options, role_options)
-  end
-
-  defp load(socket, _) do
-    socket
-  end
-
-  defp saml_acs_url(integration) do
-    Routes.sso_url(
-      PlausibleWeb.Endpoint,
-      :saml_consume,
-      integration.identifier
-    )
-  end
-end

extra/lib/plausible_web/live/verification.ex

@@ -1,288 +0,0 @@
-defmodule PlausibleWeb.Live.Verification do
-  @moduledoc """
-  LiveView coordinating the site verification process.
-  Onboarding new sites, renders a standalone component.
-  Embedded modal variant is available for general site settings.
-  """
-  use PlausibleWeb, :live_view
-
-  import PlausibleWeb.Components.Generic
-
-  alias Plausible.InstallationSupport.{State, Verification}
-
-  @component PlausibleWeb.Live.Components.Verification
-  @slowdown_for_frequent_checking :timer.seconds(5)
-
-  def mount(
-        %{"domain" => domain} = params,
-        _session,
-        socket
-      ) do
-    current_user = socket.assigns.current_user
-
-    site =
-      Plausible.Sites.get_for_user!(current_user, domain,
-        roles: [
-          :owner,
-          :admin,
-          :editor,
-          :super_admin,
-          :viewer
-        ]
-      )
-
-    true = Plausible.Sites.regular?(site)
-
-    private = Map.get(socket.private.connect_info, :private, %{})
-
-    super_admin? = Plausible.Auth.super_admin?(current_user)
-    has_pageviews? = has_pageviews?(site)
-
-    custom_url_input? = params["custom_url"] == "true"
-
-    socket =
-      assign(socket,
-        url_to_verify: nil,
-        site: site,
-        super_admin?: super_admin?,
-        domain: domain,
-        has_pageviews?: has_pageviews?,
-        component: @component,
-        installation_type: get_installation_type(params, site),
-        report_to: self(),
-        delay: private[:delay] || 500,
-        slowdown: private[:slowdown] || 500,
-        flow: params["flow"] || "",
-        checks_pid: nil,
-        attempts: 0,
-        polling_pageviews?: false,
-        custom_url_input?: custom_url_input?
-      )
-
-    if connected?(socket) and not custom_url_input? do
-      launch_delayed(socket)
-    end
-
-    {:ok, socket}
-  end
-
-  def render(assigns) do
-    ~H"""
-    <PlausibleWeb.Components.FlowProgress.render flow={@flow} current_step="Verify installation" />
-    <.custom_url_form :if={@custom_url_input?} domain={@domain} />
-    <.live_component
-      :if={not @custom_url_input?}
-      module={@component}
-      installation_type={@installation_type}
-      domain={@domain}
-      id="verification-standalone"
-      attempts={@attempts}
-      flow={@flow}
-      awaiting_first_pageview?={not @has_pageviews?}
-      super_admin?={@super_admin?}
-    />
-    """
-  end
-
-  def handle_event("launch-verification", _, socket) do
-    launch_delayed(socket)
-    {:noreply, reset_component(socket)}
-  end
-
-  def handle_event("retry", _, socket) do
-    launch_delayed(socket)
-    {:noreply, reset_component(socket)}
-  end
-
-  def handle_event("verify-custom-url", %{"custom_url" => custom_url}, socket) do
-    socket =
-      socket
-      |> assign(url_to_verify: custom_url)
-      |> assign(custom_url_input?: false)
-
-    launch_delayed(socket)
-    {:noreply, reset_component(socket)}
-  end
-
-  def handle_info({:start, report_to}, socket) do
-    domain = socket.assigns.domain
-    checks_pid = socket.assigns.checks_pid
-
-    if is_pid(checks_pid) and Process.alive?(checks_pid) do
-      {:noreply, socket}
-    else
-      case Plausible.RateLimit.check_rate(
-             "site_verification:#{domain}",
-             :timer.minutes(60),
-             3
-           ) do
-        {:allow, _} -> :ok
-        {:deny, _} -> :timer.sleep(@slowdown_for_frequent_checking)
-      end
-
-      {:ok, pid} =
-        Verification.Checks.run(
-          socket.assigns.url_to_verify,
-          domain,
-          socket.assigns.installation_type,
-          report_to: report_to,
-          slowdown: socket.assigns.slowdown
-        )
-
-      {:noreply, assign(socket, checks_pid: pid, attempts: socket.assigns.attempts + 1)}
-    end
-  end
-
-  def handle_info({:check_start, {check, state}}, socket) do
-    to_update = [message: check.report_progress_as()]
-
-    to_update =
-      if is_binary(state.url) do
-        Keyword.put(to_update, :url_to_verify, state.url)
-      else
-        to_update
-      end
-
-    update_component(socket, to_update)
-
-    {:noreply, socket}
-  end
-
-  def handle_info({:all_checks_done, %State{} = state}, socket) do
-    interpretation = Verification.Checks.interpret_diagnostics(state)
-
-    if not socket.assigns.has_pageviews? do
-      schedule_pageviews_check(socket)
-    end
-
-    update_component(socket,
-      finished?: true,
-      success?: interpretation.ok?,
-      interpretation: interpretation,
-      verification_state: state
-    )
-
-    {:noreply, assign(socket, checks_pid: nil)}
-  end
-
-  def handle_info(:check_pageviews, socket) do
-    socket =
-      if has_pageviews?(socket.assigns.site) do
-        redirect_to_stats(socket)
-      else
-        socket
-        |> assign(polling_pageviews?: false)
-        |> schedule_pageviews_check()
-      end
-
-    {:noreply, socket}
-  end
-
-  @supported_installation_types_atoms PlausibleWeb.Tracker.supported_installation_types()
-                                      |> Enum.map(&String.to_atom/1)
-  defp get_installation_type(params, site) do
-    cond do
-      params["installation_type"] in PlausibleWeb.Tracker.supported_installation_types() ->
-        params["installation_type"]
-
-      (saved_installation_type = get_saved_installation_type(site)) in @supported_installation_types_atoms ->
-        Atom.to_string(saved_installation_type)
-
-      true ->
-        PlausibleWeb.Tracker.fallback_installation_type()
-    end
-  end
-
-  defp get_saved_installation_type(site) do
-    case PlausibleWeb.Tracker.get_tracker_script_configuration(site) do
-      %{installation_type: installation_type} ->
-        installation_type
-
-      _ ->
-        nil
-    end
-  end
-
-  defp schedule_pageviews_check(socket) do
-    if socket.assigns.polling_pageviews? do
-      socket
-    else
-      Process.send_after(self(), :check_pageviews, socket.assigns.delay * 2)
-      assign(socket, polling_pageviews?: true)
-    end
-  end
-
-  defp redirect_to_stats(socket) do
-    stats_url = Routes.stats_path(PlausibleWeb.Endpoint, :stats, socket.assigns.domain, [])
-    redirect(socket, to: stats_url)
-  end
-
-  defp reset_component(socket) do
-    update_component(socket,
-      message: "We're visiting your site to ensure that everything is working",
-      finished?: false,
-      success?: false,
-      diagnostics: nil
-    )
-
-    socket
-  end
-
-  defp update_component(_socket, updates) do
-    send_update(
-      @component,
-      Keyword.merge(updates, id: "verification-standalone")
-    )
-  end
-
-  defp launch_delayed(socket) do
-    Process.send_after(self(), {:start, socket.assigns.report_to}, socket.assigns.delay)
-  end
-
-  defp has_pageviews?(site) do
-    Plausible.Stats.Clickhouse.has_pageviews?(site)
-  end
-
-  defp custom_url_form(assigns) do
-    ~H"""
-    <.focus_box>
-      <div class="mx-auto flex h-12 w-12 items-center justify-center rounded-full bg-blue-100 dark:bg-blue-900">
-        <Heroicons.globe_alt class="h-6 w-6 text-blue-600 dark:text-blue-200" />
-      </div>
-      <div class="mt-8">
-        <h3 class="text-lg leading-6 font-medium text-gray-900 dark:text-white">
-          Enter Your Custom URL
-        </h3>
-        <p class="text-sm mt-4 text-gray-600 dark:text-gray-400">
-          Please enter the URL where your website with the Plausible script is located.
-        </p>
-        <form phx-submit="verify-custom-url" class="mt-6">
-          <div class="mb-4">
-            <label
-              for="custom_url"
-              class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2"
-            >
-              Website URL
-            </label>
-            <input
-              type="url"
-              name="custom_url"
-              id="custom_url"
-              required
-              class="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-md shadow-xs focus:outline-hidden focus:ring-indigo-500 focus:border-indigo-500 dark:bg-gray-800 dark:text-white"
-              placeholder={"https://#{@domain}"}
-              value={"https://#{@domain}"}
-            />
-          </div>
-          <button
-            type="submit"
-            class="w-full flex justify-center py-2 px-4 border border-transparent rounded-md shadow-xs text-sm font-medium text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-hidden focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 dark:bg-indigo-500 dark:hover:bg-indigo-600"
-          >
-            Verify Installation
-          </button>
-        </form>
-      </div>
-    </.focus_box>
-    """
-  end
-end

extra/lib/plausible_web/plugins/api/controllers/funnels.ex

@@ -1,120 +0,0 @@
-defmodule PlausibleWeb.Plugins.API.Controllers.Funnels do
-  @moduledoc """
-  Controller for the Funnel resource under Plugins API
-  """
-  use PlausibleWeb, :plugins_api_controller
-
-  operation(:create,
-    operation_id: "Funnel.GetOrCreate",
-    summary: "Get or create Funnel",
-    request_body: {"Funnel params", "application/json", Schemas.Funnel.CreateRequest},
-    responses: %{
-      created: {"Funnel", "application/json", Schemas.Funnel},
-      unauthorized: {"Unauthorized", "application/json", Schemas.Unauthorized},
-      payment_required: {"Payment required", "application/json", Schemas.PaymentRequired},
-      unprocessable_entity:
-        {"Unprocessable entity", "application/json", Schemas.UnprocessableEntity}
-    }
-  )
-
-  def create(
-        %{private: %{open_api_spex: %{body_params: body_params}}} = conn,
-        _params
-      ) do
-    site = conn.assigns.authorized_site
-
-    case Plausible.Plugins.API.Funnels.create(site, body_params) do
-      {:ok, funnel} ->
-        headers = [{"location", plugins_api_funnels_url(conn, :get, funnel.id)}]
-
-        conn
-        |> prepend_resp_headers(headers)
-        |> put_view(Views.Funnel)
-        |> put_status(:created)
-        |> render("funnel.json", funnel: funnel, authorized_site: site)
-
-      {:error, :upgrade_required} ->
-        payment_required(conn)
-
-      {:error, changeset} ->
-        Errors.error(conn, 422, changeset)
-    end
-  end
-
-  operation(:index,
-    summary: "Retrieve Funnels",
-    parameters: [
-      limit: [in: :query, type: :integer, description: "Maximum entries per page", example: 10],
-      after: [
-        in: :query,
-        type: :string,
-        description: "Cursor value to seek after - generated internally"
-      ],
-      before: [
-        in: :query,
-        type: :string,
-        description: "Cursor value to seek before - generated internally"
-      ]
-    ],
-    responses: %{
-      ok: {"Funnels response", "application/json", Schemas.Funnel.ListResponse},
-      unauthorized: {"Unauthorized", "application/json", Schemas.Unauthorized}
-    }
-  )
-
-  @spec index(Plug.Conn.t(), %{}) :: Plug.Conn.t()
-  def index(conn, _params) do
-    {:ok, pagination} = API.Funnels.get_funnels(conn.assigns.authorized_site, conn.query_params)
-
-    conn
-    |> put_view(Views.Funnel)
-    |> render("index.json", %{pagination: pagination})
-  end
-
-  operation(:get,
-    summary: "Retrieve Funnel by ID",
-    parameters: [
-      id: [
-        in: :path,
-        type: :integer,
-        description: "Funnel ID",
-        example: 123,
-        required: true
-      ]
-    ],
-    responses: %{
-      ok: {"Goal", "application/json", Schemas.Funnel},
-      not_found: {"NotFound", "application/json", Schemas.NotFound},
-      unauthorized: {"Unauthorized", "application/json", Schemas.Unauthorized},
-      unprocessable_entity:
-        {"Unprocessable entity", "application/json", Schemas.UnprocessableEntity}
-    }
-  )
-
-  @spec get(Plug.Conn.t(), map()) :: Plug.Conn.t()
-  def get(%{private: %{open_api_spex: %{params: %{id: id}}}} = conn, _params) do
-    site = conn.assigns.authorized_site
-
-    case API.Funnels.get(site, id) do
-      nil ->
-        conn
-        |> put_view(Views.Error)
-        |> put_status(:not_found)
-        |> render("404.json")
-
-      funnel ->
-        conn
-        |> put_view(Views.Funnel)
-        |> put_status(:ok)
-        |> render("funnel.json", funnel: funnel, authorized_site: site)
-    end
-  end
-
-  defp payment_required(conn) do
-    Errors.error(
-      conn,
-      402,
-      "#{Plausible.Billing.Feature.Funnels.display_name()} is part of the Plausible Business plan. To get access to this feature, please upgrade your account."
-    )
-  end
-end

extra/lib/plausible_web/plugins/api/schemas/funnel.ex

@@ -1,55 +0,0 @@
-defmodule PlausibleWeb.Plugins.API.Schemas.Funnel do
-  @moduledoc """
-  OpenAPI schema for Funnel
-  """
-  use Plausible.Funnel.Const
-  use PlausibleWeb, :open_api_schema
-
-  OpenApiSpex.schema(%{
-    title: "Funnel",
-    description: "Funnel object",
-    type: :object,
-    properties: %{
-      funnel: %Schema{
-        type: :object,
-        required: [:id, :name, :steps],
-        properties: %{
-          id: %Schema{type: :integer, description: "Funnel ID"},
-          name: %Schema{type: :string, description: "Name"},
-          steps: %Schema{
-            description: "Funnel Steps",
-            type: :array,
-            minItems: 2,
-            maxItems: Funnel.Const.max_steps(),
-            items: Schemas.Goal
-          }
-        }
-      }
-    },
-    example: %{
-      funnel: %{
-        id: 123,
-        name: "My Marketing Funnel",
-        steps: [
-          %{
-            goal_type: "Goal.Pageview",
-            goal: %{
-              id: 1,
-              display_name: "Visit /product/1",
-              path: "/product/1"
-            }
-          },
-          %{
-            goal_type: "Goal.Revenue",
-            goal: %{
-              id: 2,
-              display_name: "Purchase",
-              currency: "EUR",
-              event_name: "Purchase"
-            }
-          }
-        ]
-      }
-    }
-  })
-end

extra/lib/plausible_web/plugins/api/schemas/funnel/create_request.ex

@@ -1,56 +0,0 @@
-defmodule PlausibleWeb.Plugins.API.Schemas.Funnel.CreateRequest do
-  @moduledoc """
-  OpenAPI schema for Funnel creation request - get or creates goals along the way
-  """
-  use Plausible.Funnel.Const
-  use PlausibleWeb, :open_api_schema
-
-  OpenApiSpex.schema(%{
-    title: "Funnel.CreateRequest",
-    description: "Funnel creation params",
-    type: :object,
-    required: [:funnel],
-    properties: %{
-      funnel: %Schema{
-        type: :object,
-        required: [:steps, :name],
-        properties: %{
-          steps: %Schema{
-            description: "Funnel Steps",
-            type: :array,
-            minItems: 2,
-            maxItems: Funnel.Const.max_steps(),
-            items: %Schema{
-              oneOf: [
-                Schemas.Goal.CreateRequest.CustomEvent,
-                Schemas.Goal.CreateRequest.Revenue,
-                Schemas.Goal.CreateRequest.Pageview
-              ]
-            }
-          },
-          name: %Schema{type: :string, description: "Funnel Name"}
-        }
-      }
-    },
-    example: %{
-      funnel: %{
-        name: "My First Funnel",
-        steps: [
-          %{
-            goal_type: "Goal.Pageview",
-            goal: %{
-              path: "/product/123"
-            }
-          },
-          %{
-            goal_type: "Goal.Revenue",
-            goal: %{
-              currency: "EUR",
-              event_name: "Purchase"
-            }
-          }
-        ]
-      }
-    }
-  })
-end

extra/lib/plausible_web/plugins/api/schemas/funnel/list_response.ex

@@ -1,26 +0,0 @@
-defmodule PlausibleWeb.Plugins.API.Schemas.Funnel.ListResponse do
-  @moduledoc """
-  OpenAPI schema for Funnel list response
-  """
-  use PlausibleWeb, :open_api_schema
-
-  OpenApiSpex.schema(%{
-    title: "Funnel.ListResponse",
-    description: "Funnels list response",
-    type: :object,
-    required: [:funnels, :meta],
-    properties: %{
-      funnels: %Schema{
-        items: Schemas.Funnel,
-        type: :array
-      },
-      meta: %Schema{
-        required: [:pagination],
-        type: :object,
-        properties: %{
-          pagination: Schemas.PaginationMetadata
-        }
-      }
-    }
-  })
-end

extra/lib/plausible_web/plugins/api/views/funnel.ex

@@ -1,53 +0,0 @@
-defmodule PlausibleWeb.Plugins.API.Views.Funnel do
-  @moduledoc """
-  View for rendering Funnels in the Plugins API
-  """
-
-  use PlausibleWeb, :plugins_api_view
-
-  def render("index.json", %{
-        pagination: %{entries: funnels, metadata: metadata},
-        authorized_site: site,
-        conn: conn
-      }) do
-    %{
-      funnels:
-        render_many(funnels, __MODULE__, "funnel.json", authorized_site: site, as: :funnel),
-      meta: render_metadata_links(metadata, :plugins_api_funnels_url, :index, conn.query_params)
-    }
-  end
-
-  def render("index.json", %{
-        funnels: funnels,
-        authorized_site: site,
-        conn: conn
-      }) do
-    %{
-      funnels:
-        render_many(funnels, __MODULE__, "funnel.json", authorized_site: site, as: :funnel),
-      meta: render_metadata_links(%{}, :plugins_api_funnels_url, :index, conn.query_params)
-    }
-  end
-
-  def render(
-        "funnel.json",
-        %{
-          funnel: funnel,
-          authorized_site: site
-        }
-      ) do
-    goals = Enum.map(funnel.steps, & &1.goal)
-
-    %{
-      funnel: %{
-        name: funnel.name,
-        id: funnel.id,
-        steps:
-          render_many(goals, PlausibleWeb.Plugins.API.Views.Goal, "goal.json",
-            authorized_site: site,
-            as: :goal
-          )
-      }
-    }
-  end
-end

extra/lib/plausible_web/plugs/handle_expired_session.ex

@@ -1,64 +0,0 @@
-defmodule Plausible.Plugs.HandleExpiredSession do
-  @moduledoc """
-  Plug for handling expired session. Must be added after `AuthPlug`.
-  """
-
-  use Plausible
-
-  import Plug.Conn
-
-  alias PlausibleWeb.Router.Helpers, as: Routes
-
-  def init(_) do
-    []
-  end
-
-  def call(conn, []) do
-    maybe_trigger_login(conn, conn.assigns[:expired_session])
-  end
-
-  defp maybe_trigger_login(conn, nil), do: conn
-
-  defp maybe_trigger_login(conn, user_session) do
-    if Plausible.Users.type(user_session.user) == :sso do
-      Plausible.Auth.UserSessions.revoke_by_id(user_session.user, user_session.id)
-      trigger_sso_login(conn, user_session.user.email)
-    else
-      conn
-    end
-  end
-
-  defp trigger_sso_login(%{method: "GET"} = conn, email) do
-    return_to =
-      if conn.query_string && String.length(conn.query_string) > 0 do
-        conn.request_path <> "?" <> conn.query_string
-      else
-        conn.request_path
-      end
-
-    conn
-    |> Phoenix.Controller.redirect(
-      to:
-        Routes.sso_path(conn, :login_form,
-          prefer: "manual",
-          email: email,
-          autosubmit: true,
-          return_to: return_to
-        )
-    )
-    |> halt()
-  end
-
-  defp trigger_sso_login(conn, email) do
-    conn
-    |> Phoenix.Controller.redirect(
-      to:
-        Routes.sso_path(conn, :login_form,
-          prefer: "manual",
-          email: email,
-          autosubmit: true
-        )
-    )
-    |> halt()
-  end
-end

extra/lib/plausible_web/plugs/secure_sso.ex

@@ -1,39 +0,0 @@
-defmodule PlausibleWeb.Plugs.SecureSSO do
-  @moduledoc """
-  Plug for securing SSO routes by setting proper policies in headers.
-  """
-
-  alias PlausibleWeb.Router.Helpers, as: Routes
-
-  @csp """
-       default-src 'none';
-       script-src 'self' 'nonce-<%= nonce %>' 'report-sample';
-       img-src 'self' 'report-sample';
-       report-uri <%= report_path %>;
-       report-to csp-report-endpoint
-       """
-       |> String.replace("\n", " ")
-
-  @behaviour Plug
-  import Plug.Conn
-
-  @impl true
-  def init(opts), do: opts
-
-  @impl true
-  def call(conn, _) do
-    nonce = :crypto.strong_rand_bytes(18) |> Base.encode64()
-    csp_report_path = Routes.sso_path(conn, :csp_report)
-
-    conn
-    |> put_private(:sso_nonce, nonce)
-    |> Phoenix.Controller.put_secure_browser_headers(%{
-      "cache-control" => "no-cache, no-store, must-revalidate",
-      "pragma" => "no-cache",
-      "reporting-endpoints" => "csp-report-endpoint=\"#{csp_report_path}\"",
-      "content-security-policy" =>
-        EEx.eval_string(@csp, nonce: nonce, report_path: csp_report_path),
-      "x-xss-protection" => "1; mode=block"
-    })
-  end
-end

extra/lib/plausible_web/sso/fake_saml_adapter.ex

@@ -1,77 +0,0 @@
-defmodule PlausibleWeb.SSO.FakeSAMLAdapter do
-  @moduledoc """
-  Fake implementation of SAML authentication interface.
-  """
-
-  alias Plausible.Auth
-  alias Plausible.Auth.SSO
-  alias Plausible.Repo
-
-  alias PlausibleWeb.Router.Helpers, as: Routes
-
-  def signin(conn, params) do
-    conn
-    |> Phoenix.Controller.put_layout(false)
-    |> Phoenix.Controller.render("saml_signin.html",
-      integration_id: params["integration_id"],
-      email: params["email"],
-      return_to: params["return_to"],
-      nonce: conn.private[:sso_nonce]
-    )
-  end
-
-  def consume(conn, params) do
-    case SSO.get_integration(params["integration_id"]) do
-      {:ok, integration} ->
-        session_timeout_minutes = integration.team.policy.sso_session_timeout_minutes
-
-        expires_at =
-          NaiveDateTime.add(NaiveDateTime.utc_now(:second), session_timeout_minutes, :minute)
-
-        identity =
-          if user = Repo.get_by(Auth.User, email: params["email"]) do
-            %SSO.Identity{
-              id: user.sso_identity_id || Ecto.UUID.generate(),
-              integration_id: integration.identifier,
-              name: user.name,
-              email: user.email,
-              expires_at: expires_at
-            }
-          else
-            %SSO.Identity{
-              id: Ecto.UUID.generate(),
-              integration_id: integration.identifier,
-              name: name_from_email(params["email"]),
-              email: params["email"],
-              expires_at: expires_at
-            }
-          end
-
-        "sso_login_success"
-        |> Plausible.Audit.Entry.new(identity, %{team_id: integration.team.id})
-        |> Plausible.Audit.Entry.include_change(identity)
-        |> Plausible.Audit.Entry.persist!()
-
-        PlausibleWeb.UserAuth.log_in_user(conn, identity, params["return_to"])
-
-      {:error, :not_found} ->
-        conn
-        |> Phoenix.Controller.put_flash(
-          :login_error,
-          "We couldn't find a Single Sign-On account for that email."
-        )
-        |> Phoenix.Controller.redirect(
-          to: Routes.sso_path(conn, :login_form, return_to: params["return_to"])
-        )
-    end
-  end
-
-  defp name_from_email(email) do
-    email
-    |> String.split("@", parts: 2)
-    |> List.first()
-    |> String.split(".")
-    |> Enum.take(2)
-    |> Enum.map_join(" ", &String.capitalize/1)
-  end
-end

extra/lib/plausible_web/sso/real_saml_adapter.ex

@@ -1,244 +0,0 @@
-defmodule PlausibleWeb.SSO.RealSAMLAdapter do
-  @moduledoc """
-  Real implementation of SAML authentication interface.
-  """
-  alias Plausible.Auth.SSO
-
-  alias PlausibleWeb.Router.Helpers, as: Routes
-
-  @deflate "urn:oasis:names:tc:SAML:2.0:bindings:URL-Encoding:DEFLATE"
-
-  @cookie_name "session_saml"
-  @cookie_seconds 10 * 60
-
-  def signin(conn, %{"integration_id" => integration_id} = params) do
-    email = params["email"]
-    return_to = params["return_to"]
-
-    case SSO.get_integration(integration_id) do
-      {:ok, integration} ->
-        sp_entity_id = SSO.SAMLConfig.entity_id(integration)
-        relay_state = gen_id()
-        id = "saml_flow_#{gen_id()}"
-
-        auth_xml = generate_auth_request(sp_entity_id, id, DateTime.utc_now())
-
-        params = %{
-          "SAMLEncoding" => @deflate,
-          "SAMLRequest" => Base.encode64(:zlib.zip(auth_xml)),
-          "RelayState" => relay_state,
-          "login_hint" => email
-        }
-
-        url = %URI{} = URI.parse(integration.config.idp_signin_url)
-
-        query_string =
-          (url.query || "")
-          |> URI.decode_query()
-          |> Map.merge(params)
-          |> URI.encode_query()
-
-        url = URI.to_string(%{url | query: query_string})
-
-        conn
-        |> Plug.Conn.configure_session(renew: true)
-        |> set_cookie(
-          relay_state: relay_state,
-          return_to: return_to
-        )
-        |> Phoenix.Controller.redirect(external: url)
-
-      {:error, :not_found} ->
-        conn
-        |> Phoenix.Controller.put_flash(
-          :login_error,
-          "We couldn't find a Single Sign-On account for that email."
-        )
-        |> Phoenix.Controller.redirect(
-          to: Routes.sso_path(conn, :login_form, return_to: return_to)
-        )
-    end
-  end
-
-  def consume(conn, _params) do
-    integration_id = conn.path_params["integration_id"]
-    saml_response = conn.body_params["SAMLResponse"]
-    relay_state = conn.body_params["RelayState"] |> safe_decode_www_form()
-
-    case get_cookie(conn) do
-      {:ok, cookie} ->
-        conn
-        |> clear_cookie()
-        |> consume(integration_id, cookie, saml_response, relay_state)
-
-      {:error, :session_expired} ->
-        conn
-        |> Phoenix.Controller.put_flash(:login_error, "Session expired.")
-        |> Phoenix.Controller.redirect(to: Routes.sso_path(conn, :login_form))
-    end
-  end
-
-  @verify_opts if Mix.env() == :test, do: [skip_time_conditions?: true], else: []
-
-  defp consume(conn, integration_id, cookie, saml_response, relay_state) do
-    with {:ok, integration} <- SSO.get_integration(integration_id),
-         :ok <- validate_authresp(cookie, relay_state),
-         {:ok, {root, assertion}} <- SimpleSaml.parse_response(saml_response),
-         {:ok, cert} <- convert_pem_cert(integration.config.idp_cert_pem),
-         public_key = X509.Certificate.public_key(cert),
-         :ok <-
-           SimpleSaml.verify_and_validate_response(root, assertion, public_key, @verify_opts),
-         {:ok, attributes} <- extract_attributes(assertion) do
-      session_timeout_minutes = integration.team.policy.sso_session_timeout_minutes
-
-      expires_at =
-        NaiveDateTime.add(NaiveDateTime.utc_now(:second), session_timeout_minutes, :minute)
-
-      identity =
-        %SSO.Identity{
-          id: assertion.name_id,
-          integration_id: integration.identifier,
-          name: name_from_attributes(attributes),
-          email: attributes.email,
-          expires_at: expires_at
-        }
-
-      "sso_login_success"
-      |> Plausible.Audit.Entry.new(identity, %{team_id: integration.team.id})
-      |> Plausible.Audit.Entry.include_change(identity)
-      |> Plausible.Audit.Entry.persist!()
-
-      PlausibleWeb.UserAuth.log_in_user(conn, identity, cookie.return_to)
-    else
-      {:error, :not_found} ->
-        login_error(
-          conn,
-          cookie,
-          "We couldn't find a Single Sign-On account for that email."
-        )
-
-      {:error, reason} ->
-        with {:ok, integration} <- SSO.get_integration(integration_id) do
-          "sso_login_failure"
-          |> Plausible.Audit.Entry.new(integration, %{team_id: integration.team.id})
-          |> Plausible.Audit.Entry.include_change(%{
-            error: inspect(reason)
-          })
-          |> Plausible.Audit.Entry.persist!()
-        end
-
-        login_error(conn, cookie, "Authentication failed (reason: #{inspect(reason)})")
-    end
-  end
-
-  defp convert_pem_cert(cert) do
-    case X509.Certificate.from_pem(cert) do
-      {:ok, cert} -> {:ok, cert}
-      {:error, _} -> {:error, :malformed_certificate}
-    end
-  end
-
-  defp name_from_attributes(attributes) do
-    [attributes.first_name, attributes.last_name]
-    |> Enum.reject(&is_nil/1)
-    |> Enum.join(" ")
-    |> String.trim()
-  end
-
-  defp extract_attributes(assertion) do
-    attributes =
-      Enum.reduce([:email, :first_name, :last_name], %{}, fn field, attrs ->
-        value =
-          assertion.attributes
-          |> Map.get(to_string(field), [])
-          |> List.first()
-
-        Map.put(attrs, field, String.trim(value || ""))
-      end)
-
-    cond do
-      attributes.email == "" ->
-        {:error, :missing_email_attribute}
-
-      # very rudimentary way to check if the attribute is at least email-like
-      not String.contains?(attributes.email, "@") or String.length(attributes.email) < 3 ->
-        {:error, :invalid_email_attribute}
-
-      attributes.first_name == "" and attributes.last_name == "" ->
-        {:error, :missing_name_attributes}
-
-      true ->
-        {:ok, attributes}
-    end
-  end
-
-  defp safe_decode_www_form(nil), do: ""
-  defp safe_decode_www_form(data), do: URI.decode_www_form(data)
-
-  defp generate_auth_request(issuer_id, id, timestamp) do
-    XmlBuilder.generate(
-      {:"samlp:AuthnRequest",
-       [
-         "xmlns:samlp": "urn:oasis:names:tc:SAML:2.0:protocol",
-         ID: id,
-         Version: "2.0",
-         IssueInstant: DateTime.to_iso8601(timestamp)
-       ], [{:"saml:Issuer", ["xmlns:saml": "urn:oasis:names:tc:SAML:2.0:assertion"], issuer_id}]}
-    )
-  end
-
-  defp validate_authresp(%{relay_state: relay_state}, relay_state)
-       when byte_size(relay_state) == 32 do
-    :ok
-  end
-
-  defp validate_authresp(_, _), do: {:error, :invalid_relay_state}
-
-  defp gen_id() do
-    24 |> :crypto.strong_rand_bytes() |> Base.url_encode64()
-  end
-
-  @doc false
-  def set_cookie(conn, attrs) do
-    attrs = %{
-      relay_state: Keyword.fetch!(attrs, :relay_state),
-      return_to: Keyword.fetch!(attrs, :return_to)
-    }
-
-    Plug.Conn.put_resp_cookie(conn, @cookie_name, attrs,
-      domain: conn.private.phoenix_endpoint.host(),
-      secure: true,
-      encrypt: true,
-      max_age: @cookie_seconds,
-      same_site: "None"
-    )
-  end
-
-  defp get_cookie(conn) do
-    conn = Plug.Conn.fetch_cookies(conn, encrypted: [@cookie_name])
-
-    if cookie = conn.cookies[@cookie_name] do
-      {:ok, cookie}
-    else
-      {:error, :session_expired}
-    end
-  end
-
-  defp clear_cookie(conn) do
-    Plug.Conn.delete_resp_cookie(conn, @cookie_name,
-      domain: conn.private.phoenix_endpoint.host(),
-      secure: true,
-      encrypt: true,
-      max_age: @cookie_seconds,
-      same_site: "None"
-    )
-  end
-
-  defp login_error(conn, cookie, login_error) do
-    conn
-    |> Phoenix.Controller.put_flash(:login_error, login_error)
-    |> Phoenix.Controller.redirect(
-      to: Routes.sso_path(conn, :login_form, return_to: cookie.return_to)
-    )
-  end
-end

extra/lib/plausible_web/templates/help_scout/layout.html.heex

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html lang="en" class="h-full plausible">
-  <head>
-    <meta charset="utf-8" />
-    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Plausible · HelpScout Integration</title>
-    <link rel="stylesheet" href={Routes.static_path(@conn, "/css/app.css")} />
-  </head>
-  <body class="flex flex-col bg-gray-50">
-    {@inner_content}
-  </body>
-</html>

extra/lib/plausible_web/templates/sso/cta.html.heex

@@ -1,18 +0,0 @@
-<.settings_tiles>
-  <.tile docs="sso">
-    <:title>
-      <a id="sso-config">Single Sign-On</a>
-    </:title>
-
-    <.upgrade title="Available on our Enterprise plan">
-      <:icon>
-        <Heroicons.cloud solid class="size-6" />
-      </:icon>
-      Restrict access so only team members signing in via SSO can access your account. <br />Email
-      <.styled_link href="mailto:hello@plausible.io" class="font-medium">
-        hello@plausible.io
-      </.styled_link>
-      to upgrade.
-    </.upgrade>
-  </.tile>
-</.settings_tiles>

extra/lib/plausible_web/templates/sso/login_form.html.heex

@@ -1,54 +0,0 @@
-<.auth_container>
-  <script :if={@autosubmit}>
-    document.addEventListener("DOMContentLoaded", function () {
-      document.getElementById("sso-login-form").submit();
-    });
-  </script>
-
-  <.form
-    :let={f}
-    id="sso-login-form"
-    for={@conn}
-    action={Routes.sso_path(@conn, :login)}
-    class="flex flex-col gap-y-6"
-  >
-    <div class="flex flex-col gap-y-2">
-      <label for={f[:email].id} class="text-sm font-semibold text-gray-800 dark:text-gray-200">
-        Email
-      </label>
-      <div>
-        <.input
-          type="email"
-          autocomplete="username"
-          placeholder="example@email.com"
-          field={f[:email]}
-          mt?={false}
-          autofocus="autofocus"
-        />
-      </div>
-      <p
-        :if={login_error = Phoenix.Flash.get(@flash, :login_error)}
-        class="text-xs text-red-500"
-      >
-        {login_error}
-      </p>
-    </div>
-
-    <input type="hidden" name="return_to" value={@conn.params["return_to"]} />
-
-    <div class="flex flex-col gap-y-4">
-      <.button class="w-full" type="submit" mt?={false}>Sign in</.button>
-
-      <p class="text-sm text-center text-gray-500 dark:text-gray-400">
-        <.styled_link href={
-          Routes.auth_path(@conn, :login_form,
-            return_to: @conn.params["return_to"],
-            prefer: "manual"
-          )
-        }>
-          Use password instead
-        </.styled_link>
-      </p>
-    </div>
-  </.form>
-</.auth_container>

extra/lib/plausible_web/templates/sso/provision_issue.html.heex

@@ -1,38 +0,0 @@
-<.auth_container>
-  <div class="flex flex-col items-center gap-y-4 text-center text-base text-gray-500 dark:text-gray-400 text-pretty">
-    <p>
-      The owner of
-      <span :if={is_nil(@conn.assigns[:current_team])}>the team</span><span
-        :if={@conn.assigns[:current_team]}
-        class="font-semibold"
-      >"{@conn.assigns[:current_team].name}"</span>
-      has turned off email and password logins, so you can only sign in with your organization's Single Sign-On.
-      <span :if={@issue == :not_a_member}>
-        To access this team, you must be added as a team member first.
-      </span>
-      <span :if={@issue == :multiple_memberships}>
-        To access this team, you must leave all other teams first.
-      </span>
-      <span :if={@issue == :multiple_memberships_noforce}>
-        To sign in with SSO, you must leave all other teams first.
-      </span>
-      <span :if={@issue == :active_personal_team}>
-        To access this team, remove or transfer all sites under
-        <span class="font-semibold">"My Personal Sites"</span>
-        and cancel its subscription if active.
-      </span>
-      <span :if={@issue == :active_personal_team_noforce}>
-        To sign in with SSO, remove or transfer all sites under
-        <span class="font-semibold">"My Personal Sites"</span>
-        and cancel its subscription if active.
-      </span>
-    </p>
-
-    <p :if={!@conn.assigns[:current_user]}>
-      <.styled_link href={Routes.auth_path(@conn, :login_form, prefer: "manual")}>
-        Sign in with email and password
-      </.styled_link>
-      to resolve the issue.
-    </p>
-  </div>
-</.auth_container>

extra/lib/plausible_web/templates/sso/provision_notice.html.heex

@@ -1,17 +0,0 @@
-<.auth_container>
-  <div class="flex flex-col items-center gap-y-4 text-center text-base text-gray-500 dark:text-gray-400 text-pretty">
-    <p>
-      The owner of
-      <span :if={is_nil(@conn.assigns[:current_team])}>the team</span><span
-        :if={@conn.assigns[:current_team]}
-        class="font-semibold"
-      >"{@conn.assigns[:current_team].name}"</span>
-      has turned off email and password logins, so you can only sign in with your organization's Single Sign-On.
-    </p>
-    <p>
-      To access this team,
-      <.styled_link href={Routes.auth_path(@conn, :logout)}>sign out</.styled_link>
-      and sign in with SSO.
-    </p>
-  </div>
-</.auth_container>

extra/lib/plausible_web/templates/sso/saml_signin.html.heex

@@ -1,36 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-  </head>
-  <body>
-    <script nonce={@nonce}>
-      document.addEventListener("DOMContentLoaded", function () {
-        document.getElementById("sso-req-form").submit();
-      });
-    </script>
-    <div>
-      <h1>
-        Processing Single Sign-On request...
-      </h1>
-      <noscript>
-        <p>
-          Since your browser does not support JavaScript, you must press
-          the button below to proceed.
-        </p>
-      </noscript>
-      <.form
-        :let={f}
-        id="sso-req-form"
-        for={@conn}
-        action={Routes.sso_path(@conn, :saml_consume, @integration_id)}
-      >
-        <.input type="hidden" field={f[:email]} />
-        <.input type="hidden" field={f[:return_to]} />
-
-        <.button class="w-full" type="submit">sign in</.button>
-      </.form>
-    </div>
-  </body>
-</html>

extra/lib/plausible_web/templates/sso/sso_settings.html.heex

@@ -1,3 +0,0 @@
-<.settings_tiles>
-  {live_render(@conn, PlausibleWeb.Live.SSOManagement, id: "sso-management")}
-</.settings_tiles>

extra/lib/plausible_web/templates/sso/team_sessions.html.heex

@@ -1,36 +0,0 @@
-<.settings_tiles>
-  <.tile docs="sso#team-management">
-    <:title>
-      <a id="user-sessions">SSO Login Management</a>
-    </:title>
-    <:subtitle>
-      Review and log out Single Sign-On user sessions
-    </:subtitle>
-
-    <div :if={@sso_sessions == []} class="mt-4 dark:text-gray-100 text-center">
-      There are currently no active SSO sessions
-    </div>
-
-    <.table id="sso-sessions-list" rows={@sso_sessions}>
-      <:thead>
-        <.th>User</.th>
-        <.th hide_on_mobile>Device</.th>
-        <.th hide_on_mobile>Last seen</.th>
-        <.th invisible>Actions</.th>
-      </:thead>
-      <:tbody :let={session}>
-        <.td truncate max_width="max-w-40">{session.user.name}</.td>
-        <.td hide_on_mobile>{session.device}</.td>
-        <.td hide_on_mobile>{Plausible.Auth.UserSessions.last_used_humanize(session)}</.td>
-        <.td :if={@current_user_session.id == session.id} actions>Current session</.td>
-        <.td :if={@current_user_session.id != session.id} actions>
-          <.delete_button
-            href={Routes.sso_path(@conn, :delete_session, session.id)}
-            method="delete"
-            data-confirm="Are you sure you want to log out this session?"
-          />
-        </.td>
-      </:tbody>
-    </.table>
-  </.tile>
-</.settings_tiles>

extra/lib/plausible_web/views/help_scout_view.ex

@@ -1,297 +0,0 @@
-defmodule PlausibleWeb.HelpScoutView do
-  use PlausibleWeb, :extra_view
-
-  def render("callback.html", assigns) do
-    ~H"""
-    <.layout xhr?={assigns[:xhr?]}>
-      <div class="search">
-        <form action="/helpscout/search">
-          <p class="entry w-full">
-            <input
-              type="text"
-              name="term"
-              class="w-48 bg-gray-50 border border-gray-300 text-gray-900 text-sm rounded-lg focus:ring-blue-500 focus:border-blue-500 block p-2.5"
-              value={assigns[:email]}
-            />
-            <input type="submit" name="search" value="&nbsp;&#x1F50E;&nbsp;" />
-          </p>
-          <input type="hidden" name="token" value={@token} />
-          <input type="hidden" name="conversation_id" value={@conversation_id} />
-          <input type="hidden" name="customer_id" value={@customer_id} />
-        </form>
-      </div>
-
-      <%= cond do %>
-        <% @conn.assigns[:error] -> %>
-          <p>
-            Failed to get details: {@error}
-          </p>
-        <% @multiple_teams? -> %>
-          <div class="teams">
-            <p class="label">
-              <a
-                href={@user_link}
-                class="text-blue-600 dark:text-blue-500 hover:underline"
-                target="_blank"
-              >
-                Owner
-              </a>
-              of teams:
-            </p>
-
-            <div class="value">
-              <ul>
-                <li :for={team <- @teams}>
-                  <a
-                    class="text-blue-600 dark:text-blue-500 hover:underline"
-                    onclick={"loadContent('/helpscout/show?#{URI.encode_query(
-                    email: @email, 
-                    conversation_id: @conversation_id, 
-                    customer_id: @customer_id, 
-                    team_identifier: team.identifier, 
-                    token: @token)}')"}
-                    href="#"
-                  >
-                    {team.name} ({team.sites_count} sites)
-                  </a>
-                </li>
-              </ul>
-            </div>
-          </div>
-
-          <div :if={@notes} class="notes">
-            <p class="label">
-              <b>User notes</b>
-            </p>
-
-            <div class="value">
-              {PhoenixHTMLHelpers.Format.text_to_html(@notes, escape: true)}
-            </div>
-          </div>
-        <% true -> %>
-          <div :if={@team_setup?} class="team-name">
-            <p class="label">
-              Team name
-            </p>
-            <p class="value">
-              <a
-                href={@status_link}
-                class="text-blue-600 dark:text-blue-500 hover:underline"
-                target="_blank"
-              >
-                {@team_name}
-              </a>
-            </p>
-          </div>
-
-          <div class="status">
-            <p class="label">
-              Status
-            </p>
-            <p class="value">
-              <a
-                href={@status_link}
-                class="text-blue-600 dark:text-blue-500 hover:underline"
-                target="_blank"
-              >
-                {@status_label}
-              </a>
-            </p>
-          </div>
-
-          <div class="plan">
-            <p class="label">
-              Plan
-            </p>
-            <p class="value">
-              <a
-                href={@plan_link}
-                class="text-blue-600 dark:text-blue-500 hover:underline"
-                target="_blank"
-              >
-                {@plan_label}
-              </a>
-            </p>
-          </div>
-
-          <div class="sites">
-            <p class="label">
-              Owner of {@sites_count} sites
-            </p>
-            <p class="value"></p>
-          </div>
-
-          <div :if={@notes} class="notes">
-            <p class="label">
-              <b>Notes</b>
-            </p>
-
-            <div class="value">
-              {PhoenixHTMLHelpers.Format.text_to_html(@notes, escape: true)}
-            </div>
-          </div>
-      <% end %>
-    </.layout>
-    """
-  end
-
-  def render("search.html", assigns) do
-    ~H"""
-    <.layout>
-      <%= if @conn.assigns[:error] do %>
-        <p>
-          Failed to run search: {@error}
-        </p>
-      <% else %>
-        <div class="search">
-          <form action="/helpscout/search">
-            <p class="entry">
-              <input
-                type="text"
-                class="bg-gray-50 border border-gray-300 text-gray-900 text-sm rounded-lg focus:ring-blue-500 focus:border-blue-500 block w-full p-2.5"
-                name="term"
-                value={@term}
-              />
-              <input type="submit" name="search" value="&nbsp;&#x1F50E;&nbsp;" />
-            </p>
-            <input type="hidden" name="token" value={@token} />
-            <input type="hidden" name="conversation_id" value={@conversation_id} />
-            <input type="hidden" name="customer_id" value={@customer_id} />
-          </form>
-          <ul :if={length(@users) > 0}>
-            <li :for={user <- @users}>
-              <a
-                onclick={"loadContent('/helpscout/show?#{URI.encode_query(email: user.email, conversation_id: @conversation_id, customer_id: @customer_id, token: @token)}')"}
-                class="text-blue-600 dark:text-blue-500 hover:underline"
-                href="#"
-              >
-                {user.email} ({user.sites_count} sites)
-              </a>
-            </li>
-          </ul>
-          <div :if={@users == []}>
-            No match found
-          </div>
-        </div>
-      <% end %>
-    </.layout>
-    """
-  end
-
-  def render("bad_request.html", assigns) do
-    ~H"""
-    <.layout>
-      <p>Missing expected parameters</p>
-    </.layout>
-    """
-  end
-
-  attr :xhr?, :boolean, default: false
-  slot :inner_block, required: true
-
-  defp layout(assigns) do
-    if assigns.xhr? do
-      ~H"""
-      render_slot(@inner_block)
-      """
-    else
-      ~H"""
-      <!DOCTYPE html>
-      <html lang="en">
-        <head>
-          <meta charset="utf-8" />
-          <meta name="viewport" content="width=device-width, initial-scale=1" />
-          <title>Helpscout Customer Details</title>
-          <style type="text/css">
-            * {
-              margin: 0;
-              padding: 0;
-            }
-
-            body {
-              font-family: Helvetica, Arial, Sans-Serif;
-              font-size: 14px;
-            }
-
-            ul {
-              list-style-type: none;
-            }
-
-            p, ul {
-              margin-left: 1.25em;
-            }
-
-            .entry {
-              width: 100%;
-              display: flex;
-            }
-
-            ul li, .entry {
-              margin-bottom: 1.25em;
-            }
-
-            .teams .label {
-              margin-bottom: 1em;
-            }
-
-            .value {
-              margin-bottom: 1.25em;
-              font-weight: bold;
-            }
-
-            .notes .value {
-              font-weight: normal;
-            }
-          </style>
-        </head>
-
-        <body>
-          <div id="content">
-            {render_slot(@inner_block)}
-          </div>
-
-          <script type="text/javascript">
-            /*
-             * HelpScout call adjusting iframe height.
-             *
-             * Extracted from their JavaScript SDK and adapted.
-             */
-            function setAppHeight(height) {
-              window.parent.postMessage(
-                {
-                  value: height + 30,
-                  type: 'SET_APP_HEIGHT',
-                  appId: window.name && window.name.replace(/app-side-panel-|app-/, ''),
-                  iframeId: window.name
-                },
-                'https://secure.helpscout.net/'
-              )
-            }
-
-            const appContainer = document.getElementById("content")
-
-            async function loadContent(uri) {
-              const response = await fetch(uri)
-              const html = await response.text()
-              appContainer.innerHTML = html
-              setAppHeight(appContainer.clientHeight)
-            }
-
-            setAppHeight(appContainer.clientHeight)
-
-            /*
-             * Tracking any resize of integration content
-             * and adjusting iframe height accordingly.
-             */
-            const resizeObserver = new ResizeObserver(() => {
-              setAppHeight(appContainer.clientHeight)
-            })
-
-            resizeObserver.observe(appContainer)
-          </script>
-        </body>
-      </html>
-      """
-    end
-  end
-end

extra/lib/plausible_web/views/sso_view.ex

@@ -1,3 +0,0 @@
-defmodule PlausibleWeb.SSOView do
-  use PlausibleWeb, :extra_view
-end

fixture/ga4_api_disabled_error.json

@@ -1,27 +0,0 @@
-{
-  "error": {
-    "code": 403,
-    "details": [
-      {
-        "@type": "type.googleapis.com/google.rpc.Help",
-        "links": [
-          {
-            "description": "Google developers console API activation",
-            "url": "https://console.developers.google.com/apis/api/analyticsadmin.googleapis.com/overview?project=752168887897"
-          }
-        ]
-      },
-      {
-        "@type": "type.googleapis.com/google.rpc.ErrorInfo",
-        "domain": "googleapis.com",
-        "metadata": {
-          "consumer": "projects/752168887897",
-          "service": "analyticsadmin.googleapis.com"
-        },
-        "reason": "SERVICE_DISABLED"
-      }
-    ],
-    "message": "Google Analytics Admin API has not been used in project 752168887897 before or it is disabled. Enable it by visiting https://console.developers.google.com/apis/api/analyticsadmin.googleapis.com/overview?project=752168887897 then retry. If you enabled this API recently, wait a few minutes for the action to propagate to our systems and retry.",
-    "status": "PERMISSION_DENIED"
-  }
-}

fixture/ga4_end_date.json

@@ -1,38 +0,0 @@
-{
-  "kind": "analyticsData#batchRunReports",
-  "reports": [
-    {
-      "dimensionHeaders": [
-        {
-          "name": "date"
-        }
-      ],
-      "kind": "analyticsData#runReport",
-      "metadata": {
-        "currencyCode": "USD",
-        "timeZone": "Europe/Warsaw"
-      },
-      "metricHeaders": [
-        {
-          "name": "screenPageViews",
-          "type": "TYPE_INTEGER"
-        }
-      ],
-      "rowCount": 3,
-      "rows": [
-        {
-          "dimensionValues": [
-            {
-              "value": "20240302"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "13"
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}

fixture/ga4_get_property.json

@@ -1,12 +0,0 @@
-{
-  "account": "accounts/28425555",
-  "createTime": "2024-02-22T10:50:15.462Z",
-  "currencyCode": "USD",
-  "displayName": "account.one - GA4",
-  "name": "properties/428685444",
-  "parent": "accounts/28425555",
-  "propertyType": "PROPERTY_TYPE_ORDINARY",
-  "serviceLevel": "GOOGLE_ANALYTICS_STANDARD",
-  "timeZone": "Europe/Warsaw",
-  "updateTime": "2024-02-22T10:50:15.462Z"
-}

fixture/ga4_list_properties.json

@@ -1,41 +0,0 @@
-{
-  "accountSummaries": [
-    {
-      "account": "accounts/28425178",
-      "displayName": "account.one",
-      "name": "accountSummaries/28425178",
-      "propertySummaries": [
-        {
-          "displayName": "account.one - GA4",
-          "parent": "accounts/28425178",
-          "property": "properties/428685906",
-          "propertyType": "PROPERTY_TYPE_ORDINARY"
-        }
-      ]
-    },
-    {
-      "account": "accounts/45336102",
-      "displayName": "account.two",
-      "name": "accountSummaries/45336102"
-    },
-    {
-      "account": "accounts/54516992",
-      "displayName": "Demo Account",
-      "name": "accountSummaries/54516992",
-      "propertySummaries": [
-        {
-          "displayName": "GA4 - Flood-It!",
-          "parent": "accounts/54516992",
-          "property": "properties/153293282",
-          "propertyType": "PROPERTY_TYPE_ORDINARY"
-        },
-        {
-          "displayName": "GA4 - Google Merch Shop",
-          "parent": "accounts/54516992",
-          "property": "properties/213025502",
-          "propertyType": "PROPERTY_TYPE_ORDINARY"
-        }
-      ]
-    }
-  ]
-}

fixture/ga4_report_imported_custom_events.json

@@ -1,1212 +0,0 @@
-{
-  "kind": "analyticsData#batchRunReports",
-  "reports": [
-    {
-      "dimensionHeaders": [
-        {
-          "name": "date"
-        },
-        {
-          "name": "eventName"
-        },
-        {
-          "name": "linkUrl"
-        }
-      ],
-      "kind": "analyticsData#runReport",
-      "metadata": {
-        "currencyCode": "USD",
-        "timeZone": "Europe/Amsterdam"
-      },
-      "metricHeaders": [
-        {
-          "name": "totalUsers",
-          "type": "TYPE_INTEGER"
-        },
-        {
-          "name": "eventCount",
-          "type": "TYPE_INTEGER"
-        }
-      ],
-      "rowCount": 56,
-      "rows": [
-        {
-          "dimensionValues": [
-            {
-              "value": "20240131"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "40"
-            },
-            {
-              "value": "55"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240130"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "42"
-            },
-            {
-              "value": "61"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240129"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "40"
-            },
-            {
-              "value": "57"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240128"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "67"
-            },
-            {
-              "value": "85"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240128"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "https://www.facebook.com/kuhinjskeprice"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240128"
-            },
-            {
-              "value": "view_search_results"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240127"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "51"
-            },
-            {
-              "value": "65"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240127"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "http://www.coolinarika.com/recept/omiljeni-mramorni-kuglof/"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240126"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "50"
-            },
-            {
-              "value": "70"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240126"
-            },
-            {
-              "value": "view_search_results"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240125"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "58"
-            },
-            {
-              "value": "98"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240125"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "https://www.google.co.uk/imgres?imgurl=http://30.media.tumblr.com/oapJteChehjbp5traCrAENnXo1_500.jpg"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240125"
-            },
-            {
-              "value": "view_search_results"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240124"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "61"
-            },
-            {
-              "value": "97"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240124"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "http://www.ikea.com/dk/da/catalog/products/20213835/"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240124"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "https://www.facebook.com/kuhinjskeprice"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240123"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "74"
-            },
-            {
-              "value": "114"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240123"
-            },
-            {
-              "value": "view_search_results"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240122"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "68"
-            },
-            {
-              "value": "95"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240122"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "https://pinterest.com/pin/68539225549526297/"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240122"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "https://www.facebook.com/kuhinjskeprice"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240121"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "116"
-            },
-            {
-              "value": "181"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240121"
-            },
-            {
-              "value": "view_search_results"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "2"
-            },
-            {
-              "value": "3"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240120"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "111"
-            },
-            {
-              "value": "190"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240120"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "https://www.facebook.com/kuhinjskeprice"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "2"
-            },
-            {
-              "value": "2"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240120"
-            },
-            {
-              "value": "view_search_results"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "2"
-            },
-            {
-              "value": "6"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240119"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "119"
-            },
-            {
-              "value": "186"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240119"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "https://www.facebook.com/kuhinjskeprice"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240119"
-            },
-            {
-              "value": "view_search_results"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240118"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "86"
-            },
-            {
-              "value": "125"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240117"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "43"
-            },
-            {
-              "value": "55"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240116"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "66"
-            },
-            {
-              "value": "95"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240116"
-            },
-            {
-              "value": "view_search_results"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240115"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "29"
-            },
-            {
-              "value": "32"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240114"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "31"
-            },
-            {
-              "value": "36"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240113"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "30"
-            },
-            {
-              "value": "34"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240113"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "http://www.coolinarika.com/recept/omiljeni-mramorni-kuglof/"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240113"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "http://www.jamieoliver.com/recipes/pasta-recipes/spinach-ricotta-cannelloni/"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240112"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "31"
-            },
-            {
-              "value": "33"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240112"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "http://www.ikea.com/dk/da/catalog/products/80010222/"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240111"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "26"
-            },
-            {
-              "value": "29"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240111"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "http://www.apartmenttherapy.com/minh-and-ted-bought-a-distress-150686"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240110"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "24"
-            },
-            {
-              "value": "28"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240109"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "32"
-            },
-            {
-              "value": "56"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240108"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "24"
-            },
-            {
-              "value": "26"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240108"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "http://www.coolinarika.com/recept/omiljeni-mramorni-kuglof/"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240107"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "27"
-            },
-            {
-              "value": "45"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240107"
-            },
-            {
-              "value": "view_search_results"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "15"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240106"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "22"
-            },
-            {
-              "value": "22"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240105"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "38"
-            },
-            {
-              "value": "39"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240104"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "24"
-            },
-            {
-              "value": "27"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240103"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "34"
-            },
-            {
-              "value": "35"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240103"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "https://pinterest.com/pin/238198267760892524/"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240102"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "29"
-            },
-            {
-              "value": "39"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240102"
-            },
-            {
-              "value": "click"
-            },
-            {
-              "value": "http://www.lonelyplanet.com/denmark/images/legoland-copenhagen$25938-2"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240101"
-            },
-            {
-              "value": "scroll"
-            },
-            {
-              "value": ""
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "20"
-            },
-            {
-              "value": "20"
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}

fixture/ga4_report_imported_devices.json

@@ -1,2556 +0,0 @@
-{
-  "kind": "analyticsData#batchRunReports",
-  "reports": [
-    {
-      "dimensionHeaders": [
-        {
-          "name": "date"
-        },
-        {
-          "name": "deviceCategory"
-        }
-      ],
-      "kind": "analyticsData#runReport",
-      "metadata": {
-        "currencyCode": "USD",
-        "timeZone": "Europe/Amsterdam"
-      },
-      "metricHeaders": [
-        {
-          "name": "screenPageViews",
-          "type": "TYPE_INTEGER"
-        },
-        {
-          "name": "totalUsers",
-          "type": "TYPE_INTEGER"
-        },
-        {
-          "name": "sessions",
-          "type": "TYPE_INTEGER"
-        },
-        {
-          "name": "bounces",
-          "type": "TYPE_INTEGER"
-        },
-        {
-          "name": "userEngagementDuration",
-          "type": "TYPE_SECONDS"
-        }
-      ],
-      "rowCount": 93,
-      "rows": [
-        {
-          "dimensionValues": [
-            {
-              "value": "20240131"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "175"
-            },
-            {
-              "value": "123"
-            },
-            {
-              "value": "128"
-            },
-            {
-              "value": "51"
-            },
-            {
-              "value": "4286"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240131"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "17"
-            },
-            {
-              "value": "15"
-            },
-            {
-              "value": "15"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "516"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240131"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "13"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240130"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "149"
-            },
-            {
-              "value": "97"
-            },
-            {
-              "value": "97"
-            },
-            {
-              "value": "37"
-            },
-            {
-              "value": "2916"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240130"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "19"
-            },
-            {
-              "value": "15"
-            },
-            {
-              "value": "15"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "464"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240130"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "101"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240129"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "113"
-            },
-            {
-              "value": "82"
-            },
-            {
-              "value": "86"
-            },
-            {
-              "value": "40"
-            },
-            {
-              "value": "2325"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240129"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "34"
-            },
-            {
-              "value": "19"
-            },
-            {
-              "value": "23"
-            },
-            {
-              "value": "13"
-            },
-            {
-              "value": "554"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240129"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "6"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "16"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240128"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "232"
-            },
-            {
-              "value": "167"
-            },
-            {
-              "value": "173"
-            },
-            {
-              "value": "67"
-            },
-            {
-              "value": "5963"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240128"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "24"
-            },
-            {
-              "value": "14"
-            },
-            {
-              "value": "14"
-            },
-            {
-              "value": "5"
-            },
-            {
-              "value": "642"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240128"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "256"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240127"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "186"
-            },
-            {
-              "value": "140"
-            },
-            {
-              "value": "142"
-            },
-            {
-              "value": "61"
-            },
-            {
-              "value": "3738"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240127"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "12"
-            },
-            {
-              "value": "11"
-            },
-            {
-              "value": "12"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "1515"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240127"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "4"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "6"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240126"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "159"
-            },
-            {
-              "value": "110"
-            },
-            {
-              "value": "119"
-            },
-            {
-              "value": "47"
-            },
-            {
-              "value": "3948"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240126"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "25"
-            },
-            {
-              "value": "18"
-            },
-            {
-              "value": "19"
-            },
-            {
-              "value": "9"
-            },
-            {
-              "value": "1368"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240126"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "5"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "229"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240125"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "180"
-            },
-            {
-              "value": "127"
-            },
-            {
-              "value": "131"
-            },
-            {
-              "value": "62"
-            },
-            {
-              "value": "3652"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240125"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "37"
-            },
-            {
-              "value": "21"
-            },
-            {
-              "value": "21"
-            },
-            {
-              "value": "7"
-            },
-            {
-              "value": "1500"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240125"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "12"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "213"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240124"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "183"
-            },
-            {
-              "value": "119"
-            },
-            {
-              "value": "128"
-            },
-            {
-              "value": "55"
-            },
-            {
-              "value": "3609"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240124"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "35"
-            },
-            {
-              "value": "15"
-            },
-            {
-              "value": "17"
-            },
-            {
-              "value": "8"
-            },
-            {
-              "value": "781"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240124"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "64"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240123"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "226"
-            },
-            {
-              "value": "142"
-            },
-            {
-              "value": "146"
-            },
-            {
-              "value": "52"
-            },
-            {
-              "value": "4415"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240123"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "38"
-            },
-            {
-              "value": "22"
-            },
-            {
-              "value": "23"
-            },
-            {
-              "value": "8"
-            },
-            {
-              "value": "422"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240123"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "3"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "13"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240122"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "190"
-            },
-            {
-              "value": "140"
-            },
-            {
-              "value": "142"
-            },
-            {
-              "value": "63"
-            },
-            {
-              "value": "3871"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240122"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "27"
-            },
-            {
-              "value": "16"
-            },
-            {
-              "value": "17"
-            },
-            {
-              "value": "9"
-            },
-            {
-              "value": "828"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240122"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "16"
-            },
-            {
-              "value": "5"
-            },
-            {
-              "value": "6"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "172"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240121"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "370"
-            },
-            {
-              "value": "235"
-            },
-            {
-              "value": "242"
-            },
-            {
-              "value": "100"
-            },
-            {
-              "value": "8146"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240121"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "24"
-            },
-            {
-              "value": "18"
-            },
-            {
-              "value": "24"
-            },
-            {
-              "value": "14"
-            },
-            {
-              "value": "685"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240121"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "3"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "0"
-            },
-            {
-              "value": "14"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240120"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "353"
-            },
-            {
-              "value": "197"
-            },
-            {
-              "value": "205"
-            },
-            {
-              "value": "95"
-            },
-            {
-              "value": "6141"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240120"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "29"
-            },
-            {
-              "value": "16"
-            },
-            {
-              "value": "17"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "773"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240120"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "0"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240119"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "5293"
-            },
-            {
-              "value": "202"
-            },
-            {
-              "value": "40"
-            },
-            {
-              "value": "15"
-            },
-            {
-              "value": "93328"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240119"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "277"
-            },
-            {
-              "value": "178"
-            },
-            {
-              "value": "187"
-            },
-            {
-              "value": "85"
-            },
-            {
-              "value": "5160"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240119"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "0"
-            },
-            {
-              "value": "61"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240118"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "241"
-            },
-            {
-              "value": "156"
-            },
-            {
-              "value": "164"
-            },
-            {
-              "value": "75"
-            },
-            {
-              "value": "4570"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240118"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "36"
-            },
-            {
-              "value": "20"
-            },
-            {
-              "value": "21"
-            },
-            {
-              "value": "10"
-            },
-            {
-              "value": "983"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240118"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "0"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240117"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "242"
-            },
-            {
-              "value": "180"
-            },
-            {
-              "value": "191"
-            },
-            {
-              "value": "82"
-            },
-            {
-              "value": "6238"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240117"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "25"
-            },
-            {
-              "value": "21"
-            },
-            {
-              "value": "21"
-            },
-            {
-              "value": "12"
-            },
-            {
-              "value": "504"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240117"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "4"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "35"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240116"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "244"
-            },
-            {
-              "value": "182"
-            },
-            {
-              "value": "184"
-            },
-            {
-              "value": "61"
-            },
-            {
-              "value": "8239"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240116"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "33"
-            },
-            {
-              "value": "16"
-            },
-            {
-              "value": "17"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "945"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240116"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "3"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "0"
-            },
-            {
-              "value": "197"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240115"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "275"
-            },
-            {
-              "value": "225"
-            },
-            {
-              "value": "238"
-            },
-            {
-              "value": "79"
-            },
-            {
-              "value": "9717"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240115"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "30"
-            },
-            {
-              "value": "25"
-            },
-            {
-              "value": "26"
-            },
-            {
-              "value": "6"
-            },
-            {
-              "value": "1668"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240115"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "6"
-            },
-            {
-              "value": "5"
-            },
-            {
-              "value": "5"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "980"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240114"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "280"
-            },
-            {
-              "value": "225"
-            },
-            {
-              "value": "237"
-            },
-            {
-              "value": "77"
-            },
-            {
-              "value": "10320"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240114"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "17"
-            },
-            {
-              "value": "14"
-            },
-            {
-              "value": "16"
-            },
-            {
-              "value": "7"
-            },
-            {
-              "value": "590"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240114"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "5"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "163"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240113"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "255"
-            },
-            {
-              "value": "220"
-            },
-            {
-              "value": "230"
-            },
-            {
-              "value": "89"
-            },
-            {
-              "value": "9574"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240113"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "19"
-            },
-            {
-              "value": "9"
-            },
-            {
-              "value": "12"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "445"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240113"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "2"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "0"
-            },
-            {
-              "value": "65"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240112"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "231"
-            },
-            {
-              "value": "187"
-            },
-            {
-              "value": "197"
-            },
-            {
-              "value": "74"
-            },
-            {
-              "value": "8567"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240112"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "32"
-            },
-            {
-              "value": "26"
-            },
-            {
-              "value": "26"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "1561"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240112"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "2"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "0"
-            },
-            {
-              "value": "67"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240111"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "212"
-            },
-            {
-              "value": "163"
-            },
-            {
-              "value": "171"
-            },
-            {
-              "value": "58"
-            },
-            {
-              "value": "7415"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240111"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "22"
-            },
-            {
-              "value": "19"
-            },
-            {
-              "value": "19"
-            },
-            {
-              "value": "6"
-            },
-            {
-              "value": "741"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240111"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "0"
-            },
-            {
-              "value": "44"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240110"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "202"
-            },
-            {
-              "value": "164"
-            },
-            {
-              "value": "175"
-            },
-            {
-              "value": "58"
-            },
-            {
-              "value": "6400"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240110"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "37"
-            },
-            {
-              "value": "23"
-            },
-            {
-              "value": "24"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "2458"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240110"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "5"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "198"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240109"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "208"
-            },
-            {
-              "value": "169"
-            },
-            {
-              "value": "178"
-            },
-            {
-              "value": "58"
-            },
-            {
-              "value": "8482"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240109"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "79"
-            },
-            {
-              "value": "30"
-            },
-            {
-              "value": "33"
-            },
-            {
-              "value": "5"
-            },
-            {
-              "value": "2900"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240109"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "3"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "0"
-            },
-            {
-              "value": "269"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240108"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "204"
-            },
-            {
-              "value": "170"
-            },
-            {
-              "value": "182"
-            },
-            {
-              "value": "65"
-            },
-            {
-              "value": "6056"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240108"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "25"
-            },
-            {
-              "value": "21"
-            },
-            {
-              "value": "23"
-            },
-            {
-              "value": "5"
-            },
-            {
-              "value": "1402"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240108"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "6"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "488"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240107"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "246"
-            },
-            {
-              "value": "191"
-            },
-            {
-              "value": "203"
-            },
-            {
-              "value": "75"
-            },
-            {
-              "value": "8711"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240107"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "24"
-            },
-            {
-              "value": "11"
-            },
-            {
-              "value": "12"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "1214"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240107"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "4"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "123"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240106"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "274"
-            },
-            {
-              "value": "235"
-            },
-            {
-              "value": "260"
-            },
-            {
-              "value": "111"
-            },
-            {
-              "value": "7478"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240106"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "22"
-            },
-            {
-              "value": "16"
-            },
-            {
-              "value": "16"
-            },
-            {
-              "value": "5"
-            },
-            {
-              "value": "835"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240106"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "7"
-            },
-            {
-              "value": "5"
-            },
-            {
-              "value": "5"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "127"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240105"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "238"
-            },
-            {
-              "value": "199"
-            },
-            {
-              "value": "209"
-            },
-            {
-              "value": "75"
-            },
-            {
-              "value": "7581"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240105"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "28"
-            },
-            {
-              "value": "23"
-            },
-            {
-              "value": "25"
-            },
-            {
-              "value": "7"
-            },
-            {
-              "value": "1518"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240105"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "4"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "4"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "212"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240104"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "230"
-            },
-            {
-              "value": "199"
-            },
-            {
-              "value": "210"
-            },
-            {
-              "value": "75"
-            },
-            {
-              "value": "9852"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240104"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "34"
-            },
-            {
-              "value": "21"
-            },
-            {
-              "value": "23"
-            },
-            {
-              "value": "6"
-            },
-            {
-              "value": "1272"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240104"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "10"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "0"
-            },
-            {
-              "value": "927"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240103"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "237"
-            },
-            {
-              "value": "203"
-            },
-            {
-              "value": "213"
-            },
-            {
-              "value": "69"
-            },
-            {
-              "value": "8451"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240103"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "37"
-            },
-            {
-              "value": "23"
-            },
-            {
-              "value": "25"
-            },
-            {
-              "value": "8"
-            },
-            {
-              "value": "1592"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240103"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "9"
-            },
-            {
-              "value": "7"
-            },
-            {
-              "value": "7"
-            },
-            {
-              "value": "2"
-            },
-            {
-              "value": "585"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240102"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "224"
-            },
-            {
-              "value": "178"
-            },
-            {
-              "value": "184"
-            },
-            {
-              "value": "51"
-            },
-            {
-              "value": "9727"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240102"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "44"
-            },
-            {
-              "value": "24"
-            },
-            {
-              "value": "25"
-            },
-            {
-              "value": "9"
-            },
-            {
-              "value": "1287"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240102"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "1"
-            },
-            {
-              "value": "0"
-            },
-            {
-              "value": "154"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240101"
-            },
-            {
-              "value": "mobile"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "205"
-            },
-            {
-              "value": "174"
-            },
-            {
-              "value": "180"
-            },
-            {
-              "value": "65"
-            },
-            {
-              "value": "7199"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240101"
-            },
-            {
-              "value": "desktop"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "12"
-            },
-            {
-              "value": "10"
-            },
-            {
-              "value": "10"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "697"
-            }
-          ]
-        },
-        {
-          "dimensionValues": [
-            {
-              "value": "20240101"
-            },
-            {
-              "value": "tablet"
-            }
-          ],
-          "metricValues": [
-            {
-              "value": "7"
-            },
-            {
-              "value": "7"
-            },
-            {
-              "value": "7"
-            },
-            {
-              "value": "3"
-            },
-            {
-              "value": "184"
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}