* `dev.secret.exs`: custom additional configuration for `MIX_ENV=dev`
* `prod.secret.exs`: custom additional configuration for `MIX_ENV=prod`
+## Block functionality
+
+ config :pleroma, :activitypub,
+ accept_blocks: true,
+ unfollow_blocked: true,
+ outgoing_blocks: true
+
+ config :pleroma, :user, deny_follow_blocked: true
+
+* `accept_blocks`: whether to accept incoming block activities from
+ other instances
+* `unfollow_blocked`: whether blocks result in people getting
+ unfollowed
+* `outgoing_blocks`: whether to federate blocks to other instances
+* `deny_follow_blocked`: whether to disallow following an account that
+ has blocked the user in question
+
## Message Rewrite Filters (MRFs)
Modify incoming and outgoing posts.
metadata: [:request_id]
config :mime, :types, %{
+ "application/xml" => ["xml"],
"application/xrd+xml" => ["xrd+xml"],
"application/activity+json" => ["activity+json"],
"application/ld+json" => ["activity+json"]
public: true,
quarantined_instances: []
-config :pleroma, :activitypub, accept_blocks: true
+config :pleroma, :activitypub,
+ accept_blocks: true,
+ unfollow_blocked: true,
+ outgoing_blocks: true
+
+config :pleroma, :user, deny_follow_blocked: true
config :pleroma, :mrf_rejectnonpublic,
allow_followersonly: false,
end
def maybe_direct_follow(%User{} = follower, %User{info: info} = followed) do
+ user_config = Application.get_env(:pleroma, :user)
+ deny_follow_blocked = Keyword.get(user_config, :deny_follow_blocked)
+
user_info = user_info(followed)
should_direct_follow =
false
# if the users are blocking each other, we shouldn't even be here, but check for it anyway
- User.blocks?(follower, followed) == true or User.blocks?(followed, follower) == true ->
+ deny_follow_blocked and
+ (User.blocks?(follower, followed) or User.blocks?(followed, follower)) ->
false
# if OStatus, then there is no three-way handshake to follow
end
def follow(%User{} = follower, %User{info: info} = followed) do
+ user_config = Application.get_env(:pleroma, :user)
+ deny_follow_blocked = Keyword.get(user_config, :deny_follow_blocked)
+
ap_followers = followed.follower_address
cond do
following?(follower, followed) or info["deactivated"] ->
{:error, "Could not follow user: #{followed.nickname} is already on your list."}
- blocks?(followed, follower) ->
+ deny_follow_blocked and blocks?(followed, follower) ->
{:error, "Could not follow user: #{followed.nickname} blocked you."}
true ->
end
def block(blocker, blocked, activity_id \\ nil, local \\ true) do
- follow_activity = fetch_latest_follow(blocker, blocked)
+ ap_config = Application.get_env(:pleroma, :activitypub)
+ unfollow_blocked = Keyword.get(ap_config, :unfollow_blocked)
+ outgoing_blocks = Keyword.get(ap_config, :outgoing_blocks)
- if follow_activity do
- unfollow(blocker, blocked, nil, local)
+ with true <- unfollow_blocked do
+ follow_activity = fetch_latest_follow(blocker, blocked)
+
+ if follow_activity do
+ unfollow(blocker, blocked, nil, local)
+ end
end
- with block_data <- make_block_data(blocker, blocked, activity_id),
+ with true <- outgoing_blocks,
+ block_data <- make_block_data(blocker, blocked, activity_id),
{:ok, activity} <- insert(block_data, local),
:ok <- maybe_federate(activity) do
{:ok, activity}
+ else
+ _e -> {:ok, nil}
end
end
json(conn, %{})
end
+ def search2(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
+ accounts = User.search(query, params["resolve"] == "true")
+
+ fetched =
+ if Regex.match?(~r/https?:/, query) do
+ with {:ok, activities} <- OStatus.fetch_activity_from_url(query) do
+ activities
+ |> Enum.filter(fn
+ %{data: %{"type" => "Create"}} -> true
+ _ -> false
+ end)
+ else
+ _e -> []
+ end
+ end || []
+
+ q =
+ from(
+ a in Activity,
+ where: fragment("?->>'type' = 'Create'", a.data),
+ where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
+ where:
+ fragment(
+ "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
+ a.data,
+ ^query
+ ),
+ limit: 20,
+ order_by: [desc: :id]
+ )
+
+ statuses = Repo.all(q) ++ fetched
+
+ tags_path = Web.base_url() <> "/tag/"
+
+ tags =
+ String.split(query)
+ |> Enum.uniq()
+ |> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
+ |> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
+ |> Enum.map(fn tag -> %{name: tag, url: tags_path <> tag} end)
+
+ res = %{
+ "accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
+ "statuses" =>
+ StatusView.render("index.json", activities: statuses, for: user, as: :activity),
+ "hashtags" => tags
+ }
+
+ json(conn, res)
+ end
+
def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
accounts = User.search(query, params["resolve"] == "true")
boost_modal: false,
delete_modal: true,
auto_play_gif: false,
- reduce_motion: false
+ display_sensitive_media: false,
+ reduce_motion: false,
+ max_toot_chars: Keyword.get(@instance, :limit)
},
compose: %{
me: "#{user.id}",
avatar_static: image,
header: header,
header_static: header,
+ emojis: [],
+ fields: [],
source: %{
note: "",
privacy: "public",
get("/accounts/:id/following", MastodonAPIController, :following)
get("/accounts/:id", MastodonAPIController, :user)
+ get("/trends", MastodonAPIController, :empty_array)
+
get("/search", MastodonAPIController, :search)
end
+ scope "/api/v2", Pleroma.Web.MastodonAPI do
+ pipe_through(:api)
+ get("/search", MastodonAPIController, :search2)
+ end
+
scope "/api", Pleroma.Web do
pipe_through(:config)
avatar_static: "http://localhost:4001/images/avi.png",
header: "http://localhost:4001/images/banner.png",
header_static: "http://localhost:4001/images/banner.png",
+ emojis: [],
+ fields: [],
source: %{
note: "",
privacy: "public",
projects / akkoma / commitdiff