mirror of
https://framagit.org/framasoft/mobilizon.git
synced 2024-12-25 01:12:30 +00:00
ed3cd5858c
When loading a page, we inject various meta tags in the HTML. These made database calls everytime Signed-off-by: Thomas Citharel <tcit@tcit.fr>
631 lines
20 KiB
Elixir
631 lines
20 KiB
Elixir
defmodule Mobilizon.GraphQL.Resolvers.Admin do
|
|
@moduledoc """
|
|
Handles the report-related GraphQL calls.
|
|
"""
|
|
|
|
import Mobilizon.Users.Guards
|
|
|
|
alias Mobilizon.{Actors, Admin, Config, Events, Instances, Users}
|
|
alias Mobilizon.Actors.{Actor, Follower}
|
|
alias Mobilizon.Admin.{ActionLog, Setting}
|
|
alias Mobilizon.Cldr.Language
|
|
alias Mobilizon.Config
|
|
alias Mobilizon.Discussions.Comment
|
|
alias Mobilizon.Events.Event
|
|
alias Mobilizon.Federation.ActivityPub.{Actions, Relay}
|
|
alias Mobilizon.Reports.{Note, Report}
|
|
alias Mobilizon.Service.Auth.Authenticator
|
|
alias Mobilizon.Service.Statistics
|
|
alias Mobilizon.Storage.Page
|
|
alias Mobilizon.Users.User
|
|
alias Mobilizon.Web.Email
|
|
import Mobilizon.Web.Gettext
|
|
require Logger
|
|
|
|
@spec list_action_logs(any(), map(), Absinthe.Resolution.t()) ::
|
|
{:ok, Page.t(ActionLog.t())} | {:error, String.t()}
|
|
def list_action_logs(
|
|
_parent,
|
|
%{page: page, limit: limit},
|
|
%{context: %{current_user: %User{role: role}}}
|
|
)
|
|
when is_moderator(role) do
|
|
with %Page{elements: action_logs, total: total} <-
|
|
Mobilizon.Admin.list_action_logs(page, limit) do
|
|
action_logs =
|
|
action_logs
|
|
|> Enum.map(fn %ActionLog{
|
|
target_type: target_type,
|
|
action: action,
|
|
actor: actor,
|
|
id: id,
|
|
inserted_at: inserted_at
|
|
} = action_log ->
|
|
target_type
|
|
|> String.to_existing_atom()
|
|
|> transform_action_log(action, action_log)
|
|
|> add_extra_data(actor, id, inserted_at)
|
|
end)
|
|
|> Enum.filter(& &1)
|
|
|
|
{:ok, %Page{elements: action_logs, total: total}}
|
|
end
|
|
end
|
|
|
|
def list_action_logs(_parent, _args, _resolution) do
|
|
{:error, dgettext("errors", "You need to be logged-in and a moderator to list action logs")}
|
|
end
|
|
|
|
defp add_extra_data(nil, _actor, _id, _inserted_at), do: nil
|
|
|
|
defp add_extra_data(map, actor, id, inserted_at) do
|
|
Map.merge(map, %{actor: actor, id: id, inserted_at: inserted_at})
|
|
end
|
|
|
|
@spec transform_action_log(module(), atom(), ActionLog.t()) :: map() | nil
|
|
defp transform_action_log(
|
|
Report,
|
|
:update,
|
|
%ActionLog{} = action_log
|
|
) do
|
|
with %Report{} = report <- Mobilizon.Reports.get_report(action_log.target_id) do
|
|
action =
|
|
case action_log do
|
|
%ActionLog{changes: %{"status" => "closed"}} -> :report_update_closed
|
|
%ActionLog{changes: %{"status" => "open"}} -> :report_update_opened
|
|
%ActionLog{changes: %{"status" => "resolved"}} -> :report_update_resolved
|
|
end
|
|
|
|
%{
|
|
action: action,
|
|
object: report
|
|
}
|
|
end
|
|
end
|
|
|
|
defp transform_action_log(Note, :create, %ActionLog{changes: changes}) do
|
|
%{
|
|
action: :note_creation,
|
|
object: convert_changes_to_struct(Note, changes)
|
|
}
|
|
end
|
|
|
|
defp transform_action_log(Note, :delete, %ActionLog{changes: changes}) do
|
|
%{
|
|
action: :note_deletion,
|
|
object: convert_changes_to_struct(Note, changes)
|
|
}
|
|
end
|
|
|
|
defp transform_action_log(Event, :delete, %ActionLog{changes: changes}) do
|
|
%{
|
|
action: :event_deletion,
|
|
object: convert_changes_to_struct(Event, changes)
|
|
}
|
|
end
|
|
|
|
defp transform_action_log(Comment, :delete, %ActionLog{changes: changes}) do
|
|
%{
|
|
action: :comment_deletion,
|
|
object: convert_changes_to_struct(Comment, changes)
|
|
}
|
|
end
|
|
|
|
defp transform_action_log(Actor, :suspend, %ActionLog{changes: changes}) do
|
|
%{
|
|
action: :actor_suspension,
|
|
object: convert_changes_to_struct(Actor, changes)
|
|
}
|
|
end
|
|
|
|
defp transform_action_log(Actor, :unsuspend, %ActionLog{changes: changes}) do
|
|
%{
|
|
action: :actor_unsuspension,
|
|
object: convert_changes_to_struct(Actor, changes)
|
|
}
|
|
end
|
|
|
|
defp transform_action_log(User, :delete, %ActionLog{changes: changes}) do
|
|
%{
|
|
action: :user_deletion,
|
|
object: convert_changes_to_struct(User, changes)
|
|
}
|
|
end
|
|
|
|
defp transform_action_log(_, _, _), do: nil
|
|
|
|
# Changes are stored as %{"key" => "value"} so we need to convert them back as struct
|
|
@spec convert_changes_to_struct(module(), map()) :: struct()
|
|
defp convert_changes_to_struct(struct, %{"report_id" => _report_id} = changes) do
|
|
data = for({key, val} <- changes, into: %{}, do: {String.to_existing_atom(key), val})
|
|
data = Map.put(data, :report, Mobilizon.Reports.get_report(data.report_id))
|
|
struct(struct, data)
|
|
end
|
|
|
|
defp convert_changes_to_struct(struct, changes) do
|
|
changeset = struct.__changeset__
|
|
|
|
data =
|
|
for(
|
|
{key, val} <- changes,
|
|
into: %{},
|
|
do: {String.to_existing_atom(key), process_eventual_type(changeset, key, val)}
|
|
)
|
|
|
|
struct(struct, data)
|
|
end
|
|
|
|
# datetimes are not unserialized as DateTime/NaiveDateTime so we do it manually with changeset data
|
|
@spec process_eventual_type(Ecto.Changeset.t(), String.t(), String.t() | nil) ::
|
|
DateTime.t() | NaiveDateTime.t() | any()
|
|
defp process_eventual_type(changeset, key, val) do
|
|
cond do
|
|
changeset[String.to_existing_atom(key)] == Mobilizon.Actors.ActorType and not is_nil(val) ->
|
|
String.to_existing_atom(val)
|
|
|
|
changeset[String.to_existing_atom(key)] == :utc_datetime and not is_nil(val) ->
|
|
{:ok, datetime, _} = DateTime.from_iso8601(val)
|
|
datetime
|
|
|
|
changeset[String.to_existing_atom(key)] == :naive_datetime and not is_nil(val) ->
|
|
{:ok, datetime} = NaiveDateTime.from_iso8601(val)
|
|
datetime
|
|
|
|
true ->
|
|
val
|
|
end
|
|
end
|
|
|
|
@spec get_list_of_languages(any(), any(), any()) :: {:ok, String.t()} | {:error, any()}
|
|
def get_list_of_languages(_parent, %{codes: codes}, _resolution) when is_list(codes) do
|
|
locale = Mobilizon.Cldr.locale_or_default(Gettext.get_locale())
|
|
|
|
case Language.known_languages(String.to_existing_atom(locale)) do
|
|
data when is_map(data) ->
|
|
data
|
|
|> Enum.map(fn {code, elem} ->
|
|
%{code: code, name: Map.get(elem, :standard, "Unknown")}
|
|
end)
|
|
|> Enum.filter(fn %{code: code, name: _name} -> code in codes end)
|
|
|> (&{:ok, &1}).()
|
|
|
|
{:error, err} ->
|
|
{:error, err}
|
|
end
|
|
end
|
|
|
|
def get_list_of_languages(_parent, _args, _resolution) do
|
|
locale = Gettext.get_locale()
|
|
|
|
case Language.known_languages(String.to_existing_atom(locale)) do
|
|
data when is_map(data) ->
|
|
data =
|
|
Enum.map(data, fn {code, elem} ->
|
|
%{code: code, name: Map.get(elem, :standard, "Unknown")}
|
|
end)
|
|
|
|
{:ok, data}
|
|
|
|
{:error, err} ->
|
|
{:error, err}
|
|
end
|
|
end
|
|
|
|
@spec get_dashboard(any(), any(), Absinthe.Resolution.t()) ::
|
|
{:ok, map()} | {:error, String.t()}
|
|
def get_dashboard(_parent, _args, %{context: %{current_user: %User{role: role}}})
|
|
when is_admin(role) do
|
|
last_public_event_published =
|
|
case Events.list_events(1, 1, :inserted_at, :desc) do
|
|
%Page{elements: [event | _]} -> event
|
|
_ -> nil
|
|
end
|
|
|
|
{:ok,
|
|
%{
|
|
number_of_users: Statistics.get_cached_value(:local_users),
|
|
number_of_events: Statistics.get_cached_value(:local_events),
|
|
number_of_groups: Statistics.get_cached_value(:local_groups),
|
|
number_of_comments: Statistics.get_cached_value(:local_comments),
|
|
number_of_confirmed_participations_to_local_events:
|
|
Statistics.get_cached_value(:confirmed_participations_to_local_events),
|
|
number_of_reports: Mobilizon.Reports.count_opened_reports(),
|
|
number_of_followers: Statistics.get_cached_value(:instance_followers),
|
|
number_of_followings: Statistics.get_cached_value(:instance_followings),
|
|
last_public_event_published: last_public_event_published,
|
|
last_group_created: Actors.last_group_created()
|
|
}}
|
|
end
|
|
|
|
def get_dashboard(_parent, _args, _resolution) do
|
|
{:error,
|
|
dgettext(
|
|
"errors",
|
|
"You need to be logged-in and an administrator to access dashboard statistics"
|
|
)}
|
|
end
|
|
|
|
@spec get_settings(any(), any(), Absinthe.Resolution.t()) :: {:ok, map()} | {:error, String.t()}
|
|
def get_settings(_parent, _args, %{
|
|
context: %{current_user: %User{role: role}}
|
|
})
|
|
when is_admin(role) do
|
|
{:ok, Config.admin_settings()}
|
|
end
|
|
|
|
def get_settings(_parent, _args, _resolution) do
|
|
{:error,
|
|
dgettext("errors", "You need to be logged-in and an administrator to access admin settings")}
|
|
end
|
|
|
|
@spec save_settings(any(), map(), Absinthe.Resolution.t()) ::
|
|
{:ok, map()} | {:error, String.t()}
|
|
def save_settings(_parent, args, %{
|
|
context: %{current_user: %User{role: role}}
|
|
})
|
|
when is_admin(role) do
|
|
with {:ok, res} <- Admin.save_settings("instance", args),
|
|
res <-
|
|
res
|
|
|> Enum.map(fn {key, %Setting{value: value}} ->
|
|
{key, Admin.get_setting_value(value)}
|
|
end)
|
|
|> Enum.into(%{}),
|
|
:ok <- eventually_update_instance_actor(res) do
|
|
Config.clear_config_cache()
|
|
|
|
{:ok, res}
|
|
end
|
|
end
|
|
|
|
def save_settings(_parent, _args, _resolution) do
|
|
{:error,
|
|
dgettext("errors", "You need to be logged-in and an administrator to save admin settings")}
|
|
end
|
|
|
|
@spec update_user(any, map(), Absinthe.Resolution.t()) ::
|
|
{:error, :invalid_argument | :user_not_found | binary | Ecto.Changeset.t()}
|
|
| {:ok, Mobilizon.Users.User.t()}
|
|
def update_user(_parent, %{id: id, notify: notify} = args, %{
|
|
context: %{current_user: %User{role: role}}
|
|
})
|
|
when is_admin(role) do
|
|
case Users.get_user(id) do
|
|
nil ->
|
|
{:error, :user_not_found}
|
|
|
|
%User{} = user ->
|
|
case args |> Map.drop([:notify, :id]) |> Map.keys() do
|
|
[] ->
|
|
{:error, :invalid_argument}
|
|
|
|
[change | _] ->
|
|
case change do
|
|
:email -> change_email(user, Map.get(args, :email), notify)
|
|
:role -> change_role(user, Map.get(args, :role), notify)
|
|
:confirmed -> confirm_user(user, Map.get(args, :confirmed), notify)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def update_user(_parent, _args, _resolution) do
|
|
{:error,
|
|
dgettext("errors", "You need to be logged-in and an administrator to edit an user's details")}
|
|
end
|
|
|
|
@spec change_email(User.t(), String.t(), boolean()) :: {:ok, User.t()} | {:error, String.t()}
|
|
defp change_email(%User{email: old_email} = user, new_email, notify) do
|
|
if Authenticator.can_change_email?(user) do
|
|
if new_email != old_email do
|
|
do_change_email_different(user, old_email, new_email, notify)
|
|
else
|
|
{:error, dgettext("errors", "The new email must be different")}
|
|
end
|
|
end
|
|
end
|
|
|
|
@spec do_change_email_different(User.t(), String.t(), String.t(), boolean()) ::
|
|
{:ok, User.t()} | {:error, String.t()}
|
|
defp do_change_email_different(user, old_email, new_email, notify) do
|
|
if Email.Checker.valid?(new_email) do
|
|
do_change_email(user, old_email, new_email, notify)
|
|
else
|
|
{:error, dgettext("errors", "The new email doesn't seem to be valid")}
|
|
end
|
|
end
|
|
|
|
@spec do_change_email(User.t(), String.t(), String.t(), boolean()) ::
|
|
{:ok, User.t()} | {:error, String.t()}
|
|
defp do_change_email(user, old_email, new_email, notify) do
|
|
case Users.update_user(user, %{email: new_email}) do
|
|
{:ok, %User{} = updated_user} ->
|
|
if notify do
|
|
updated_user
|
|
|> Email.Admin.user_email_change_old(old_email)
|
|
|> Email.Mailer.send_email()
|
|
|
|
updated_user
|
|
|> Email.Admin.user_email_change_new(old_email)
|
|
|> Email.Mailer.send_email()
|
|
end
|
|
|
|
{:ok, updated_user}
|
|
|
|
{:error, %Ecto.Changeset{} = err} ->
|
|
Logger.debug(inspect(err))
|
|
{:error, dgettext("errors", "Failed to update user email")}
|
|
end
|
|
end
|
|
|
|
@spec change_role(User.t(), atom(), boolean()) ::
|
|
{:ok, User.t()} | {:error, String.t() | Ecto.Changeset.t()}
|
|
defp change_role(%User{role: old_role} = user, new_role, notify) do
|
|
if old_role != new_role do
|
|
with {:ok, %User{} = user} <- Users.update_user(user, %{role: new_role}) do
|
|
if notify do
|
|
user
|
|
|> Email.Admin.user_role_change(old_role)
|
|
|> Email.Mailer.send_email()
|
|
end
|
|
|
|
{:ok, user}
|
|
end
|
|
else
|
|
{:error, dgettext("errors", "The new role must be different")}
|
|
end
|
|
end
|
|
|
|
@spec confirm_user(User.t(), boolean(), boolean()) ::
|
|
{:ok, User.t()} | {:error, String.t() | Ecto.Changeset.t()}
|
|
defp confirm_user(%User{confirmed_at: nil} = user, true, notify) do
|
|
with {:ok, %User{} = user} <-
|
|
Users.update_user(user, %{
|
|
confirmed_at: DateTime.utc_now(),
|
|
confirmation_sent_at: nil,
|
|
confirmation_token: nil
|
|
}) do
|
|
if notify do
|
|
user
|
|
|> Email.Admin.user_confirmation()
|
|
|> Email.Mailer.send_email()
|
|
end
|
|
|
|
{:ok, user}
|
|
end
|
|
end
|
|
|
|
defp confirm_user(%User{confirmed_at: %DateTime{}} = _user, true, _notify) do
|
|
{:error, dgettext("errors", "Can't confirm an already confirmed user")}
|
|
end
|
|
|
|
defp confirm_user(_user, _confirm, _notify) do
|
|
{:error, dgettext("errors", "Deconfirming users is not supported")}
|
|
end
|
|
|
|
@spec list_relay_followers(any(), map(), Absinthe.Resolution.t()) ::
|
|
{:ok, Page.t(Follower.t())} | {:error, :unauthorized | :unauthenticated}
|
|
def list_relay_followers(
|
|
_parent,
|
|
%{page: page, limit: limit},
|
|
%{context: %{current_user: %User{role: role}}}
|
|
)
|
|
when is_admin(role) do
|
|
with %Actor{} = relay_actor <- Relay.get_actor() do
|
|
%Page{} =
|
|
page = Actors.list_external_followers_for_actor_paginated(relay_actor, page, limit)
|
|
|
|
{:ok, page}
|
|
end
|
|
end
|
|
|
|
def list_relay_followers(_parent, _args, %{context: %{current_user: %User{}}}) do
|
|
{:error, :unauthorized}
|
|
end
|
|
|
|
def list_relay_followers(_parent, _args, _resolution) do
|
|
{:error, :unauthenticated}
|
|
end
|
|
|
|
@spec list_relay_followings(any(), map(), Absinthe.Resolution.t()) ::
|
|
{:ok, Page.t(Follower.t())} | {:error, :unauthorized | :unauthenticated}
|
|
def list_relay_followings(
|
|
_parent,
|
|
%{page: page, limit: limit},
|
|
%{context: %{current_user: %User{role: role}}}
|
|
)
|
|
when is_admin(role) do
|
|
with %Actor{} = relay_actor <- Relay.get_actor() do
|
|
%Page{} =
|
|
page = Actors.list_external_followings_for_actor_paginated(relay_actor, page, limit)
|
|
|
|
{:ok, page}
|
|
end
|
|
end
|
|
|
|
def list_relay_followings(_parent, _args, %{context: %{current_user: %User{}}}) do
|
|
{:error, :unauthorized}
|
|
end
|
|
|
|
def list_relay_followings(_parent, _args, _resolution) do
|
|
{:error, :unauthenticated}
|
|
end
|
|
|
|
def get_instances(
|
|
_parent,
|
|
args,
|
|
%{
|
|
context: %{current_user: %User{role: role}}
|
|
}
|
|
)
|
|
when is_admin(role) do
|
|
{:ok,
|
|
Instances.instances(
|
|
args
|
|
|> Keyword.new()
|
|
|> Keyword.take([
|
|
:page,
|
|
:limit,
|
|
:order_by,
|
|
:direction,
|
|
:filter_domain,
|
|
:filter_follow_status,
|
|
:filter_suspend_status
|
|
])
|
|
)}
|
|
end
|
|
|
|
def get_instances(_parent, _args, %{context: %{current_user: %User{}}}) do
|
|
{:error, :unauthorized}
|
|
end
|
|
|
|
def get_instances(_parent, _args, _resolution) do
|
|
{:error, :unauthenticated}
|
|
end
|
|
|
|
@spec get_instance(any, map(), Absinthe.Resolution.t()) ::
|
|
{:error, :unauthenticated | :unauthorized | :not_found}
|
|
| {:ok, Mobilizon.Instances.Instance.t()}
|
|
def get_instance(_parent, %{domain: domain}, %{
|
|
context: %{current_user: %User{role: role}}
|
|
})
|
|
when is_admin(role) do
|
|
remote_relay = Actors.get_relay(domain)
|
|
local_relay = Relay.get_actor()
|
|
|
|
result = %{
|
|
has_relay: !is_nil(remote_relay),
|
|
relay_address:
|
|
if(is_nil(remote_relay),
|
|
do: nil,
|
|
else: "#{remote_relay.preferred_username}@#{remote_relay.domain}"
|
|
),
|
|
follower_status: follow_status(remote_relay, local_relay),
|
|
followed_status: follow_status(local_relay, remote_relay)
|
|
}
|
|
|
|
case Instances.instance(domain) do
|
|
nil -> {:error, :not_found}
|
|
instance -> {:ok, Map.merge(instance, result)}
|
|
end
|
|
end
|
|
|
|
def get_instance(_parent, _args, %{context: %{current_user: %User{}}}) do
|
|
{:error, :unauthorized}
|
|
end
|
|
|
|
def get_instance(_parent, _args, _resolution) do
|
|
{:error, :unauthenticated}
|
|
end
|
|
|
|
@spec create_instance(any, map(), Absinthe.Resolution.t()) ::
|
|
{:error, atom() | binary()}
|
|
| {:ok, Mobilizon.Instances.Instance.t()}
|
|
def create_instance(
|
|
parent,
|
|
%{domain: domain} = args,
|
|
%{context: %{current_user: %User{role: role}}} = resolution
|
|
)
|
|
when is_admin(role) do
|
|
case Relay.follow(domain) do
|
|
{:ok, _activity, _follow} ->
|
|
Instances.refresh()
|
|
get_instance(parent, args, resolution)
|
|
|
|
{:error, :follow_pending} ->
|
|
{:error, dgettext("errors", "This instance is pending follow approval")}
|
|
|
|
{:error, :already_following} ->
|
|
{:error, dgettext("errors", "You are already following this instance")}
|
|
|
|
{:error, :http_error} ->
|
|
{:error, dgettext("errors", "Unable to find an instance to follow at this address")}
|
|
|
|
{:error, err} ->
|
|
{:error, err}
|
|
end
|
|
end
|
|
|
|
@spec remove_relay(any(), map(), Absinthe.Resolution.t()) ::
|
|
{:ok, Follower.t()} | {:error, any()}
|
|
def remove_relay(_parent, %{address: address}, %{context: %{current_user: %User{role: role}}})
|
|
when is_admin(role) do
|
|
with {:ok, _activity, follow} <- Relay.unfollow(address) do
|
|
{:ok, follow}
|
|
end
|
|
end
|
|
|
|
@spec accept_subscription(any(), map(), Absinthe.Resolution.t()) ::
|
|
{:ok, Follower.t()} | {:error, any()}
|
|
def accept_subscription(
|
|
_parent,
|
|
%{address: address},
|
|
%{context: %{current_user: %User{role: role}}}
|
|
)
|
|
when is_admin(role) do
|
|
with {:ok, _activity, follow} <- Relay.accept(address) do
|
|
{:ok, follow}
|
|
end
|
|
end
|
|
|
|
@spec reject_subscription(any(), map(), Absinthe.Resolution.t()) ::
|
|
{:ok, Follower.t()} | {:error, any()}
|
|
def reject_subscription(
|
|
_parent,
|
|
%{address: address},
|
|
%{context: %{current_user: %User{role: role}}}
|
|
)
|
|
when is_admin(role) do
|
|
with {:ok, _activity, follow} <- Relay.reject(address) do
|
|
{:ok, follow}
|
|
end
|
|
end
|
|
|
|
@spec eventually_update_instance_actor(map()) :: :ok | {:error, :instance_actor_update_failure}
|
|
defp eventually_update_instance_actor(admin_setting_args) do
|
|
args = %{}
|
|
new_instance_description = Map.get(admin_setting_args, :instance_description)
|
|
new_instance_name = Map.get(admin_setting_args, :instance_name)
|
|
|
|
%{
|
|
instance_description: old_instance_description,
|
|
instance_name: old_instance_name
|
|
} = Config.admin_settings()
|
|
|
|
args =
|
|
if not is_nil(new_instance_description) &&
|
|
new_instance_description != old_instance_description,
|
|
do: Map.put(args, :summary, new_instance_description),
|
|
else: args
|
|
|
|
args =
|
|
if not is_nil(new_instance_name) && new_instance_name != old_instance_name,
|
|
do: Map.put(args, :name, new_instance_name),
|
|
else: args
|
|
|
|
if args != %{} do
|
|
%Actor{} = instance_actor = Relay.get_actor()
|
|
|
|
case Actions.Update.update(instance_actor, args, true) do
|
|
{:ok, _activity, _actor} ->
|
|
:ok
|
|
|
|
{:error, _err} ->
|
|
{:error, :instance_actor_update_failure}
|
|
end
|
|
else
|
|
:ok
|
|
end
|
|
end
|
|
|
|
@spec follow_status(Actor.t() | nil, Actor.t() | nil) :: :approved | :pending | :none
|
|
defp follow_status(follower, followed) when follower != nil and followed != nil do
|
|
case Actors.check_follow(follower, followed) do
|
|
%Follower{approved: true} -> :approved
|
|
%Follower{approved: false} -> :pending
|
|
_ -> :none
|
|
end
|
|
end
|
|
|
|
defp follow_status(_, _), do: :none
|
|
end
|