towerops/lib/towerops/accounts/sessions.ex

defmodule Towerops.Accounts.Sessions do
  @moduledoc """
  Browser session lifecycle: create / list / touch / revoke / anonymize.

  Extracted from `Towerops.Accounts` to keep the context module focused on
  user identity. Operates on `Towerops.Accounts.BrowserSession` and the
  underlying `UserToken` (deleting a user token cascades to the session).
  """

  import Ecto.Query, warn: false

  alias Towerops.Accounts.BrowserSession
  alias Towerops.Accounts.UserAgentParser
  alias Towerops.Accounts.UserToken
  alias Towerops.GeoIP
  alias Towerops.Repo

  @doc """
  Create a browser session, parsing the User-Agent and enriching with GeoIP.

  ## Required attributes
  - `:user_id`, `:user_token_id`, `:ip_address`, `:user_agent`,
    `:last_activity_at`, `:expires_at`
  """
  def create(attrs) do
    user_agent = Map.get(attrs, :user_agent)
    device_info = UserAgentParser.parse(user_agent)
    location = location_for(Map.get(attrs, :ip_address))

    attrs_with_metadata =
      attrs
      |> Map.merge(device_info)
      |> Map.merge(location)

    %BrowserSession{}
    |> BrowserSession.create_changeset(attrs_with_metadata)
    |> Repo.insert()
  end

  defp location_for(ip_address) do
    case GeoIP.lookup_full(ip_address) do
      %{} = loc ->
        %{
          country_code: loc.country_code,
          country_name: loc.country_name,
          city_name: loc.city_name,
          subdivision_1_name: loc.subdivision_1_name
        }

      nil ->
        %{}
    end
  end

  @doc "List active (non-expired, non-anonymized) sessions for a user."
  def list_active(user_id) do
    now = DateTime.utc_now()

    BrowserSession
    |> where([bs], bs.user_id == ^user_id)
    |> where([bs], bs.expires_at > ^now)
    |> where([bs], is_nil(bs.anonymized_at))
    |> order_by([bs], desc: bs.last_activity_at)
    |> Repo.all()
  end

  @doc "Look up a session by its `user_token_id`."
  def get_by_token(user_token_id) do
    Repo.get_by(BrowserSession, user_token_id: user_token_id)
  end

  @doc "Look up a session by the raw token cookie value."
  def get_by_token_value(token) when is_binary(token) do
    hashed_token = :crypto.hash(:sha256, token)

    user_token =
      UserToken
      |> where([ut], ut.token == ^hashed_token)
      |> where([ut], ut.context == "session")
      |> Repo.one()

    case user_token do
      nil -> nil
      token -> get_by_token(token.id)
    end
  end

  @doc "Update `last_activity_at`."
  def touch(%BrowserSession{} = session) do
    session
    |> BrowserSession.touch_changeset()
    |> Repo.update()
  end

  @doc """
  Revoke a session, refusing to revoke the current request's session.
  Cascades through the underlying UserToken.
  """
  def revoke(session_id, _user_id, current_token_id) do
    session = Repo.get(BrowserSession, session_id)

    cond do
      is_nil(session) ->
        {:error, :not_found}

      session.user_token_id == current_token_id ->
        {:error, :self_revoke}

      true ->
        case Repo.get(UserToken, session.user_token_id) do
          nil -> {:error, :not_found}
          user_token -> Repo.delete(user_token)
        end
    end
  end

  @doc "Revoke every session for a user except `current_token_id`."
  def revoke_all_other(user_id, current_token_id) do
    session_ids =
      BrowserSession
      |> where([bs], bs.user_id == ^user_id)
      |> where([bs], bs.user_token_id != ^current_token_id)
      |> select([bs], bs.user_token_id)
      |> Repo.all()

    UserToken
    |> where([ut], ut.id in ^session_ids)
    |> Repo.delete_all()
  end

  @doc "GDPR: null out user_id on a user's sessions, keep metadata for analysis."
  def anonymize_for_user(user_id) do
    now = DateTime.utc_now()

    BrowserSession
    |> where([bs], bs.user_id == ^user_id)
    |> where([bs], is_nil(bs.anonymized_at))
    |> Repo.update_all(set: [user_id: nil, anonymized_at: now])
  end

  @doc "Delete sessions whose expires_at is in the past. Returns count."
  def delete_expired do
    now = DateTime.utc_now()

    {count, _} =
      BrowserSession
      |> where([bs], bs.expires_at < ^now)
      |> Repo.delete_all()

    count
  end
end