+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
defmodule Pleroma.ModerationLog do
use Ecto.Schema
import Ecto.Query
+ @type t :: %__MODULE__{}
+ @type log_subject :: Activity.t() | User.t() | list(User.t())
+ @type log_params :: %{
+ required(:actor) => User.t(),
+ required(:action) => String.t(),
+ optional(:subject) => log_subject(),
+ optional(:subject_actor) => User.t(),
+ optional(:subject_id) => String.t(),
+ optional(:subjects) => list(User.t()),
+ optional(:permission) => String.t(),
+ optional(:text) => String.t(),
+ optional(:sensitive) => String.t(),
+ optional(:visibility) => String.t(),
+ optional(:followed) => User.t(),
+ optional(:follower) => User.t(),
+ optional(:nicknames) => list(String.t()),
+ optional(:tags) => list(String.t()),
+ optional(:target) => String.t()
+ }
+
schema "moderation_log" do
field(:data, :map)
timestamps()
end
- def get_all(page, page_size) do
- from(q in __MODULE__,
- order_by: [desc: q.inserted_at],
- limit: ^page_size,
- offset: ^((page - 1) * page_size)
+ def get_all(params) do
+ base_query =
+ get_all_query()
+ |> maybe_filter_by_date(params)
+ |> maybe_filter_by_user(params)
+ |> maybe_filter_by_search(params)
+
+ query_with_pagination = base_query |> paginate_query(params)
+
+ %{
+ items: Repo.all(query_with_pagination),
+ count: Repo.aggregate(base_query, :count, :id)
+ }
+ end
+
+ defp maybe_filter_by_date(query, %{start_date: nil, end_date: nil}), do: query
+
+ defp maybe_filter_by_date(query, %{start_date: start_date, end_date: nil}) do
+ from(q in query,
+ where: q.inserted_at >= ^parse_datetime(start_date)
)
- |> Repo.all()
end
- def insert_log(%{
- actor: %User{} = actor,
- subject: %User{} = subject,
- action: action,
- permission: permission
- }) do
- Repo.insert(%ModerationLog{
- data: %{
- actor: user_to_map(actor),
- subject: user_to_map(subject),
- action: action,
- permission: permission
- }
- })
+ defp maybe_filter_by_date(query, %{start_date: nil, end_date: end_date}) do
+ from(q in query,
+ where: q.inserted_at <= ^parse_datetime(end_date)
+ )
end
- def insert_log(%{
- actor: %User{} = actor,
- action: "report_update",
- subject: %Activity{data: %{"type" => "Flag"}} = subject
- }) do
- Repo.insert(%ModerationLog{
- data: %{
- actor: user_to_map(actor),
- action: "report_update",
- subject: report_to_map(subject)
- }
- })
+ defp maybe_filter_by_date(query, %{start_date: start_date, end_date: end_date}) do
+ from(q in query,
+ where: q.inserted_at >= ^parse_datetime(start_date),
+ where: q.inserted_at <= ^parse_datetime(end_date)
+ )
end
- def insert_log(%{
- actor: %User{} = actor,
- action: "report_response",
- subject: %Activity{} = subject,
- text: text
- }) do
- Repo.insert(%ModerationLog{
- data: %{
- actor: user_to_map(actor),
- action: "report_response",
- subject: report_to_map(subject),
- text: text
- }
- })
+ defp maybe_filter_by_user(query, %{user_id: nil}), do: query
+
+ defp maybe_filter_by_user(query, %{user_id: user_id}) do
+ from(q in query,
+ where: fragment("(?)->'actor'->>'id' = ?", q.data, ^user_id)
+ )
end
- def insert_log(%{
- actor: %User{} = actor,
- action: "status_update",
- subject: %Activity{} = subject,
- sensitive: sensitive,
- visibility: visibility
- }) do
- Repo.insert(%ModerationLog{
- data: %{
- actor: user_to_map(actor),
- action: "status_update",
- subject: status_to_map(subject),
- sensitive: sensitive,
- visibility: visibility
- }
- })
+ defp maybe_filter_by_search(query, %{search: search}) when is_nil(search) or search == "",
+ do: query
+
+ defp maybe_filter_by_search(query, %{search: search}) do
+ from(q in query,
+ where: fragment("(?)->>'message' ILIKE ?", q.data, ^"%#{search}%")
+ )
end
- def insert_log(%{
- actor: %User{} = actor,
- action: "status_delete",
- subject_id: subject_id
- }) do
- Repo.insert(%ModerationLog{
- data: %{
- actor: user_to_map(actor),
- action: "status_delete",
- subject_id: subject_id
- }
- })
+ defp paginate_query(query, %{page: page, page_size: page_size}) do
+ from(q in query,
+ limit: ^page_size,
+ offset: ^((page - 1) * page_size)
+ )
end
- @spec insert_log(%{actor: User, subject: User, action: String.t()}) ::
- {:ok, ModerationLog} | {:error, any}
- def insert_log(%{actor: %User{} = actor, subject: subject, action: action}) do
- Repo.insert(%ModerationLog{
- data: %{
- actor: user_to_map(actor),
- action: action,
- subject: user_to_map(subject)
- }
- })
+ defp get_all_query do
+ from(q in __MODULE__,
+ order_by: [desc: q.inserted_at]
+ )
end
- @spec insert_log(%{actor: User, subjects: [User], action: String.t()}) ::
- {:ok, ModerationLog} | {:error, any}
- def insert_log(%{actor: %User{} = actor, subjects: subjects, action: action}) do
- subjects = Enum.map(subjects, &user_to_map/1)
+ defp parse_datetime(datetime) do
+ {:ok, parsed_datetime, _} = DateTime.from_iso8601(datetime)
- Repo.insert(%ModerationLog{
- data: %{
- actor: user_to_map(actor),
- action: action,
- subjects: subjects
- }
- })
+ parsed_datetime
end
- def insert_log(%{
- actor: %User{} = actor,
- followed: %User{} = followed,
- follower: %User{} = follower,
- action: "follow"
- }) do
- Repo.insert(%ModerationLog{
- data: %{
- actor: user_to_map(actor),
- action: "follow",
- followed: user_to_map(followed),
- follower: user_to_map(follower)
- }
- })
+ defp prepare_log_data(%{actor: actor, action: action} = attrs) do
+ %{
+ "actor" => user_to_map(actor),
+ "action" => action,
+ "message" => ""
+ }
+ |> Pleroma.Maps.put_if_present("subject_actor", user_to_map(attrs[:subject_actor]))
+ end
+
+ defp prepare_log_data(attrs), do: attrs
+
+ @spec insert_log(log_params()) :: {:ok, ModerationLog} | {:error, any}
+ def insert_log(%{actor: %User{}, subject: subjects, permission: permission} = attrs) do
+ data =
+ attrs
+ |> prepare_log_data
+ |> Map.merge(%{"subject" => user_to_map(subjects), "permission" => permission})
+
+ insert_log_entry_with_message(%ModerationLog{data: data})
+ end
+
+ def insert_log(%{actor: %User{}, action: action, subject: %Activity{} = subject} = attrs)
+ when action in ["report_note_delete", "report_update", "report_note"] do
+ data =
+ attrs
+ |> prepare_log_data
+ |> Pleroma.Maps.put_if_present("text", attrs[:text])
+ |> Map.merge(%{"subject" => report_to_map(subject)})
+
+ insert_log_entry_with_message(%ModerationLog{data: data})
+ end
+
+ def insert_log(
+ %{
+ actor: %User{},
+ action: action,
+ subject: %Activity{} = subject,
+ sensitive: sensitive,
+ visibility: visibility
+ } = attrs
+ )
+ when action == "status_update" do
+ data =
+ attrs
+ |> prepare_log_data
+ |> Map.merge(%{
+ "subject" => status_to_map(subject),
+ "sensitive" => sensitive,
+ "visibility" => visibility
+ })
+
+ insert_log_entry_with_message(%ModerationLog{data: data})
end
- def insert_log(%{
- actor: %User{} = actor,
- followed: %User{} = followed,
- follower: %User{} = follower,
- action: "unfollow"
- }) do
- Repo.insert(%ModerationLog{
- data: %{
- actor: user_to_map(actor),
- action: "unfollow",
- followed: user_to_map(followed),
- follower: user_to_map(follower)
- }
- })
+ def insert_log(%{actor: %User{}, action: action, subject_id: subject_id} = attrs)
+ when action == "status_delete" do
+ data =
+ attrs
+ |> prepare_log_data
+ |> Map.merge(%{"subject_id" => subject_id})
+
+ insert_log_entry_with_message(%ModerationLog{data: data})
+ end
+
+ def insert_log(%{actor: %User{}, subject: subject, action: _action} = attrs) do
+ data =
+ attrs
+ |> prepare_log_data
+ |> Map.merge(%{"subject" => user_to_map(subject)})
+
+ insert_log_entry_with_message(%ModerationLog{data: data})
+ end
+
+ def insert_log(%{actor: %User{}, subjects: subjects, action: _action} = attrs) do
+ data =
+ attrs
+ |> prepare_log_data
+ |> Map.merge(%{"subjects" => user_to_map(subjects)})
+
+ insert_log_entry_with_message(%ModerationLog{data: data})
+ end
+
+ def insert_log(
+ %{
+ actor: %User{},
+ followed: %User{} = followed,
+ follower: %User{} = follower,
+ action: action
+ } = attrs
+ )
+ when action in ["unfollow", "follow"] do
+ data =
+ attrs
+ |> prepare_log_data
+ |> Map.merge(%{"followed" => user_to_map(followed), "follower" => user_to_map(follower)})
+
+ insert_log_entry_with_message(%ModerationLog{data: data})
end
def insert_log(%{
tags: tags,
action: action
}) do
- Repo.insert(%ModerationLog{
+ %ModerationLog{
data: %{
- actor: user_to_map(actor),
- nicknames: nicknames,
- tags: tags,
- action: action
+ "actor" => user_to_map(actor),
+ "nicknames" => nicknames,
+ "tags" => tags,
+ "action" => action,
+ "message" => ""
}
- })
+ }
+ |> insert_log_entry_with_message()
end
- def insert_log(%{
- actor: %User{} = actor,
- action: action,
- target: target
- })
+ def insert_log(%{actor: %User{}, action: action, target: target} = attrs)
when action in ["relay_follow", "relay_unfollow"] do
- Repo.insert(%ModerationLog{
+ data =
+ attrs
+ |> prepare_log_data
+ |> Map.merge(%{"target" => target})
+
+ insert_log_entry_with_message(%ModerationLog{data: data})
+ end
+
+ def insert_log(%{actor: %User{} = actor, action: "chat_message_delete", subject_id: subject_id}) do
+ %ModerationLog{
data: %{
- actor: user_to_map(actor),
- action: action,
- target: target
+ "actor" => %{"nickname" => actor.nickname},
+ "action" => "chat_message_delete",
+ "subject_id" => subject_id
}
- })
+ }
+ |> insert_log_entry_with_message()
+ end
+
+ @spec insert_log_entry_with_message(ModerationLog) :: {:ok, ModerationLog} | {:error, any}
+ defp insert_log_entry_with_message(entry) do
+ entry.data["message"]
+ |> put_in(get_log_entry_message(entry))
+ |> Repo.insert()
+ end
+
+ defp user_to_map(users) when is_list(users) do
+ Enum.map(users, &user_to_map/1)
end
defp user_to_map(%User{} = user) do
user
- |> Map.from_struct()
|> Map.take([:id, :nickname])
- |> Map.put(:type, "user")
+ |> Map.new(fn {k, v} -> {Atom.to_string(k), v} end)
+ |> Map.put("type", "user")
end
+ defp user_to_map(_), do: nil
+
defp report_to_map(%Activity{} = report) do
- %{
- type: "report",
- id: report.id,
- state: report.data["state"]
- }
+ %{"type" => "report", "id" => report.id, "state" => report.data["state"]}
end
defp status_to_map(%Activity{} = status) do
- %{
- type: "status",
- id: status.id
- }
+ %{"type" => "status", "id" => status.id}
end
+ @spec get_log_entry_message(ModerationLog.t()) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"@#{actor_nickname} made @#{follower_nickname} #{action} @#{followed_nickname}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"action" => "delete",
- "subject" => %{"nickname" => subject_nickname, "type" => "user"}
+ "subject" => subjects
}
}) do
- "@#{actor_nickname} deleted user @#{subject_nickname}"
+ "@#{actor_nickname} deleted users: #{users_to_nicknames_string(subjects)}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"subjects" => subjects
}
}) do
- nicknames =
- subjects
- |> Enum.map(&"@#{&1["nickname"]}")
- |> Enum.join(", ")
-
- "@#{actor_nickname} created users: #{nicknames}"
+ "@#{actor_nickname} created users: #{users_to_nicknames_string(subjects)}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"action" => "activate",
- "subject" => %{"nickname" => subject_nickname, "type" => "user"}
+ "subject" => users
}
}) do
- "@#{actor_nickname} activated user @#{subject_nickname}"
+ "@#{actor_nickname} activated users: #{users_to_nicknames_string(users)}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"action" => "deactivate",
- "subject" => %{"nickname" => subject_nickname, "type" => "user"}
+ "subject" => users
+ }
+ }) do
+ "@#{actor_nickname} deactivated users: #{users_to_nicknames_string(users)}"
+ end
+
+ def get_log_entry_message(%ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "approve",
+ "subject" => users
+ }
+ }) do
+ "@#{actor_nickname} approved users: #{users_to_nicknames_string(users)}"
+ end
+
+ def get_log_entry_message(%ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "add_suggestion",
+ "subject" => users
+ }
+ }) do
+ "@#{actor_nickname} added suggested users: #{users_to_nicknames_string(users)}"
+ end
+
+ def get_log_entry_message(%ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "remove_suggestion",
+ "subject" => users
}
}) do
- "@#{actor_nickname} deactivated user @#{subject_nickname}"
+ "@#{actor_nickname} removed suggested users: #{users_to_nicknames_string(users)}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"action" => "tag"
}
}) do
- nicknames_string =
- nicknames
- |> Enum.map(&"@#{&1}")
- |> Enum.join(", ")
-
tags_string = tags |> Enum.join(", ")
- "@#{actor_nickname} added tags: #{tags_string} to users: #{nicknames_string}"
+ "@#{actor_nickname} added tags: #{tags_string} to users: #{nicknames_to_string(nicknames)}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"action" => "untag"
}
}) do
- nicknames_string =
- nicknames
- |> Enum.map(&"@#{&1}")
- |> Enum.join(", ")
-
tags_string = tags |> Enum.join(", ")
- "@#{actor_nickname} removed tags: #{tags_string} from users: #{nicknames_string}"
+ "@#{actor_nickname} removed tags: #{tags_string} from users: #{nicknames_to_string(nicknames)}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"action" => "grant",
- "subject" => %{"nickname" => subject_nickname},
+ "subject" => users,
"permission" => permission
}
}) do
- "@#{actor_nickname} made @#{subject_nickname} #{permission}"
+ "@#{actor_nickname} made #{users_to_nicknames_string(users)} #{permission}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"action" => "revoke",
- "subject" => %{"nickname" => subject_nickname},
+ "subject" => users,
"permission" => permission
}
}) do
- "@#{actor_nickname} revoked #{permission} role from @#{subject_nickname}"
+ "@#{actor_nickname} revoked #{permission} role from #{users_to_nicknames_string(users)}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"@#{actor_nickname} followed relay: #{target}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"@#{actor_nickname} unfollowed relay: #{target}"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
- def get_log_entry_message(%ModerationLog{
- data: %{
- "actor" => %{"nickname" => actor_nickname},
- "action" => "report_update",
- "subject" => %{"id" => subject_id, "state" => state, "type" => "report"}
- }
- }) do
- "@#{actor_nickname} updated report ##{subject_id} with '#{state}' state"
+ def get_log_entry_message(
+ %ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "report_update",
+ "subject" => %{"id" => subject_id, "state" => state, "type" => "report"}
+ }
+ } = log
+ ) do
+ "@#{actor_nickname} updated report ##{subject_id}" <>
+ subject_actor_nickname(log, " (on user ", ")") <>
+ " with '#{state}' state"
+ end
+
+ def get_log_entry_message(
+ %ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "report_note",
+ "subject" => %{"id" => subject_id, "type" => "report"},
+ "text" => text
+ }
+ } = log
+ ) do
+ "@#{actor_nickname} added note '#{text}' to report ##{subject_id}" <>
+ subject_actor_nickname(log, " on user ")
+ end
+
+ def get_log_entry_message(
+ %ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "report_note_delete",
+ "subject" => %{"id" => subject_id, "type" => "report"},
+ "text" => text
+ }
+ } = log
+ ) do
+ "@#{actor_nickname} deleted note '#{text}' from report ##{subject_id}" <>
+ subject_actor_nickname(log, " on user ")
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
- def get_log_entry_message(%ModerationLog{
- data: %{
- "actor" => %{"nickname" => actor_nickname},
- "action" => "report_response",
- "subject" => %{"id" => subject_id, "type" => "report"},
- "text" => text
- }
- }) do
- "@#{actor_nickname} responded with '#{text}' to report ##{subject_id}"
- end
-
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"@#{actor_nickname} updated status ##{subject_id}, set visibility: '#{visibility}'"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"@#{actor_nickname} updated status ##{subject_id}, set sensitive: '#{sensitive}'"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
"visibility" => visibility
}
}) do
- "@#{actor_nickname} updated status ##{subject_id}, set sensitive: '#{sensitive}', visibility: '#{
- visibility
- }'"
+ "@#{actor_nickname} updated status ##{subject_id}, set sensitive: '#{sensitive}', visibility: '#{visibility}'"
end
- @spec get_log_entry_message(ModerationLog) :: String.t()
def get_log_entry_message(%ModerationLog{
data: %{
"actor" => %{"nickname" => actor_nickname},
}) do
"@#{actor_nickname} deleted status ##{subject_id}"
end
+
+ def get_log_entry_message(%ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "force_password_reset",
+ "subject" => subjects
+ }
+ }) do
+ "@#{actor_nickname} forced password reset for users: #{users_to_nicknames_string(subjects)}"
+ end
+
+ def get_log_entry_message(%ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "confirm_email",
+ "subject" => subjects
+ }
+ }) do
+ "@#{actor_nickname} confirmed email for users: #{users_to_nicknames_string(subjects)}"
+ end
+
+ def get_log_entry_message(%ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "resend_confirmation_email",
+ "subject" => subjects
+ }
+ }) do
+ "@#{actor_nickname} re-sent confirmation email for users: #{users_to_nicknames_string(subjects)}"
+ end
+
+ def get_log_entry_message(%ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "updated_users",
+ "subject" => subjects
+ }
+ }) do
+ "@#{actor_nickname} updated users: #{users_to_nicknames_string(subjects)}"
+ end
+
+ def get_log_entry_message(%ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "chat_message_delete",
+ "subject_id" => subject_id
+ }
+ }) do
+ "@#{actor_nickname} deleted chat message ##{subject_id}"
+ end
+
+ def get_log_entry_message(%ModerationLog{
+ data: %{
+ "actor" => %{"nickname" => actor_nickname},
+ "action" => "create_backup",
+ "subject" => %{"nickname" => user_nickname}
+ }
+ }) do
+ "@#{actor_nickname} requested account backup for @#{user_nickname}"
+ end
+
+ defp nicknames_to_string(nicknames) do
+ nicknames
+ |> Enum.map(&"@#{&1}")
+ |> Enum.join(", ")
+ end
+
+ defp users_to_nicknames_string(users) do
+ users
+ |> Enum.map(&"@#{&1["nickname"]}")
+ |> Enum.join(", ")
+ end
+
+ defp subject_actor_nickname(%ModerationLog{data: data}, prefix_msg, postfix_msg \\ "") do
+ case data do
+ %{"subject_actor" => %{"nickname" => subject_actor}} ->
+ [prefix_msg, "@#{subject_actor}", postfix_msg]
+ |> Enum.reject(&(&1 == ""))
+ |> Enum.join()
+
+ _ ->
+ ""
+ end
+ end
end