@@ -1,5 +1,5 @@ | |||
defmodule Mix.Tasks.Pleroma.Common do | |||
@shortdoc "Common functions to be reused in mix tasks" | |||
@doc "Common functions to be reused in mix tasks" | |||
def start_pleroma do | |||
Mix.Task.run("app.start") | |||
end | |||
@@ -1,6 +1,5 @@ | |||
defmodule Mix.Tasks.Pleroma.Instance do | |||
use Mix.Task | |||
alias Pleroma.{Repo, User} | |||
alias Mix.Tasks.Pleroma.Common | |||
@shortdoc "Manages Pleroma instance" | |||
@@ -22,7 +22,7 @@ defmodule Mix.Tasks.Pleroma.Relay do | |||
def run(["follow", target]) do | |||
Common.start_pleroma() | |||
with {:ok, activity} <- Relay.follow(target) do | |||
with {:ok, _activity} <- Relay.follow(target) do | |||
# put this task to sleep to allow the genserver to push out the messages | |||
:timer.sleep(500) | |||
else | |||
@@ -33,7 +33,7 @@ defmodule Mix.Tasks.Pleroma.Relay do | |||
def run(["unfollow", target]) do | |||
Common.start_pleroma() | |||
with {:ok, activity} <- Relay.unfollow(target) do | |||
with {:ok, _activity} <- Relay.unfollow(target) do | |||
# put this task to sleep to allow the genserver to push out the messages | |||
:timer.sleep(500) | |||
else | |||
@@ -1,18 +1,16 @@ | |||
defmodule Mix.Tasks.Pleroma.Uploads do | |||
use Mix.Task | |||
import Mix.Ecto | |||
alias Pleroma.{Upload, Uploaders.Local, Uploaders.S3} | |||
alias Pleroma.{Upload, Uploaders.Local} | |||
alias Mix.Tasks.Pleroma.Common | |||
require Logger | |||
@log_every 50 | |||
@shortdoc "Migrate uploads from local to remote storage" | |||
@longdoc """ | |||
@doc """ | |||
Manages uploads | |||
## Migrate uploads from local to remote storage | |||
""" | |||
def run(["migrate_local", target_uploader | args]) do | |||
delete? = Enum.member?(args, "--delete") | |||
Common.start_pleroma() | |||
@@ -59,7 +57,7 @@ defmodule Mix.Tasks.Pleroma.Uploads do | |||
File.exists?(root_path) -> | |||
file = Path.basename(id) | |||
[hash, ext] = String.split(id, ".") | |||
[hash, _ext] = String.split(id, ".") | |||
{%Pleroma.Upload{id: hash, name: file, path: file, tempfile: root_path}, root_path} | |||
true -> | |||
@@ -20,7 +20,7 @@ defmodule Mix.Tasks.Pleroma.User do | |||
- `--admin`/`--no-admin` - whether the user is an admin | |||
## Generate an invite link. | |||
mix pleroma.user invite | |||
## Delete the user's account. | |||
@@ -32,7 +32,7 @@ defmodule Mix.Tasks.Pleroma.User do | |||
mix pleroma.user toggle_activated NICKNAME | |||
## Unsubscribe local users from user's account and deactivate it | |||
mix pleroma.user unsubscribe NICKNAME | |||
## Create a password reset link. | |||
@@ -235,6 +235,26 @@ defmodule Mix.Tasks.Pleroma.User do | |||
end | |||
end | |||
def run(["invite"]) do | |||
Common.start_pleroma() | |||
with {:ok, token} <- Pleroma.UserInviteToken.create_token() do | |||
Mix.shell().info("Generated user invite token") | |||
url = | |||
Pleroma.Web.Router.Helpers.redirect_url( | |||
Pleroma.Web.Endpoint, | |||
:registration_page, | |||
token.token | |||
) | |||
IO.puts(url) | |||
else | |||
_ -> | |||
Mix.shell().error("Could not create invite token.") | |||
end | |||
end | |||
defp set_moderator(user, value) do | |||
info_cng = User.Info.admin_api_update(user.info, %{is_moderator: value}) | |||
@@ -270,24 +290,4 @@ defmodule Mix.Tasks.Pleroma.User do | |||
Mix.shell().info("Locked status of #{user.nickname}: #{user.info.locked}") | |||
end | |||
def run(["invite"]) do | |||
Common.start_pleroma() | |||
with {:ok, token} <- Pleroma.UserInviteToken.create_token() do | |||
Mix.shell().info("Generated user invite token") | |||
url = | |||
Pleroma.Web.Router.Helpers.redirect_url( | |||
Pleroma.Web.Endpoint, | |||
:registration_page, | |||
token.token | |||
) | |||
IO.puts(url) | |||
else | |||
_ -> | |||
Mix.shell().error("Could not create invite token.") | |||
end | |||
end | |||
end |
@@ -15,7 +15,6 @@ defmodule Pleroma.Application do | |||
# See http://elixir-lang.org/docs/stable/elixir/Application.html | |||
# for more information on OTP Applications | |||
@env Mix.env() | |||
def start(_type, _args) do | |||
import Cachex.Spec | |||
@@ -165,7 +165,7 @@ defmodule Pleroma.Emoji do | |||
defp load_from_file_stream(stream) do | |||
stream | |||
|> Stream.map(&String.strip/1) | |||
|> Stream.map(&String.trim/1) | |||
|> Stream.map(fn line -> | |||
case String.split(line, ~r/,\s*/) do | |||
[name, file] -> {name, file} | |||
@@ -1,10 +1,10 @@ | |||
defmodule Pleroma.Filter do | |||
use Ecto.Schema | |||
import Ecto.{Changeset, Query} | |||
alias Pleroma.{User, Repo, Activity} | |||
alias Pleroma.{User, Repo} | |||
schema "filters" do | |||
belongs_to(:user, Pleroma.User) | |||
belongs_to(:user, User) | |||
field(:filter_id, :integer) | |||
field(:hide, :boolean, default: false) | |||
field(:whole_word, :boolean, default: true) | |||
@@ -26,7 +26,7 @@ defmodule Pleroma.Filter do | |||
Repo.one(query) | |||
end | |||
def get_filters(%Pleroma.User{id: user_id} = user) do | |||
def get_filters(%User{id: user_id} = _user) do | |||
query = | |||
from( | |||
f in Pleroma.Filter, | |||
@@ -38,9 +38,9 @@ defmodule Pleroma.Filter do | |||
def create(%Pleroma.Filter{user_id: user_id, filter_id: nil} = filter) do | |||
# If filter_id wasn't given, use the max filter_id for this user plus 1. | |||
# XXX This could result in a race condition if a user tries to add two | |||
# different filters for their account from two different clients at the | |||
# same time, but that should be unlikely. | |||
# XXX This could result in a race condition if a user tries to add two | |||
# different filters for their account from two different clients at the | |||
# same time, but that should be unlikely. | |||
max_id_query = | |||
from( | |||
@@ -166,7 +166,7 @@ defmodule Pleroma.HTML.Transform.MediaProxy do | |||
{"src", media_url} | |||
end | |||
def scrub_attribute(tag, attribute), do: attribute | |||
def scrub_attribute(_tag, attribute), do: attribute | |||
def scrub({"img", attributes, children}) do | |||
attributes = | |||
@@ -177,9 +177,9 @@ defmodule Pleroma.HTML.Transform.MediaProxy do | |||
{"img", attributes, children} | |||
end | |||
def scrub({:comment, children}), do: "" | |||
def scrub({:comment, _children}), do: "" | |||
def scrub({tag, attributes, children}), do: {tag, attributes, children} | |||
def scrub({tag, children}), do: children | |||
def scrub({_tag, children}), do: children | |||
def scrub(text), do: text | |||
end |
@@ -25,7 +25,7 @@ defmodule Pleroma.HTTP.Connection do | |||
# fetch Hackney options | |||
# | |||
defp hackney_options(opts \\ []) do | |||
defp hackney_options(opts) do | |||
options = Keyword.get(opts, :adapter, []) | |||
@hackney_options ++ options | |||
end | |||
@@ -23,7 +23,7 @@ defmodule Pleroma.List do | |||
|> validate_required([:following]) | |||
end | |||
def for_user(user, opts) do | |||
def for_user(user, _opts) do | |||
query = | |||
from( | |||
l in Pleroma.List, | |||
@@ -46,7 +46,7 @@ defmodule Pleroma.List do | |||
Repo.one(query) | |||
end | |||
def get_following(%Pleroma.List{following: following} = list) do | |||
def get_following(%Pleroma.List{following: following} = _list) do | |||
q = | |||
from( | |||
u in User, | |||
@@ -33,10 +33,10 @@ defmodule Pleroma.MIME do | |||
{:ok, check_mime_type(head)} | |||
end | |||
def mime_type(<<_::binary>>), do: {:ok, @default} | |||
def bin_mime_type(_), do: :error | |||
def mime_type(<<_::binary>>), do: {:ok, @default} | |||
defp fix_extension(filename, content_type) do | |||
parts = String.split(filename, ".") | |||
@@ -118,7 +118,7 @@ defmodule Pleroma.Notification do | |||
def get_notified_from_activity(activity, local_only \\ true) | |||
def get_notified_from_activity( | |||
%Activity{data: %{"to" => _, "type" => type} = data} = activity, | |||
%Activity{data: %{"to" => _, "type" => type} = _data} = activity, | |||
local_only | |||
) | |||
when type in ["Create", "Like", "Announce", "Follow"] do | |||
@@ -131,18 +131,18 @@ defmodule Pleroma.Notification do | |||
User.get_users_from_set(recipients, local_only) | |||
end | |||
def get_notified_from_activity(_, local_only), do: [] | |||
def get_notified_from_activity(_, _local_only), do: [] | |||
defp maybe_notify_to_recipients( | |||
recipients, | |||
%Activity{data: %{"to" => to, "type" => type}} = activity | |||
%Activity{data: %{"to" => to, "type" => _type}} = _activity | |||
) do | |||
recipients ++ to | |||
end | |||
defp maybe_notify_mentioned_recipients( | |||
recipients, | |||
%Activity{data: %{"to" => to, "type" => type} = data} = activity | |||
%Activity{data: %{"to" => _to, "type" => type} = data} = _activity | |||
) | |||
when type == "Create" do | |||
object = Object.normalize(data["object"]) | |||
@@ -26,14 +26,7 @@ defmodule Pleroma.Plugs.AuthenticationPlug do | |||
end | |||
end | |||
def call( | |||
%{ | |||
assigns: %{ | |||
auth_credentials: %{password: password} | |||
} | |||
} = conn, | |||
_ | |||
) do | |||
def call(%{assigns: %{auth_credentials: %{password: _}}} = conn, _) do | |||
Pbkdf2.dummy_checkpw() | |||
conn | |||
end | |||
@@ -5,7 +5,7 @@ defmodule Pleroma.Plugs.BasicAuthDecoderPlug do | |||
options | |||
end | |||
def call(conn, opts) do | |||
def call(conn, _opts) do | |||
with ["Basic " <> header] <- get_req_header(conn, "authorization"), | |||
{:ok, userinfo} <- Base.decode64(header), | |||
[username, password] <- String.split(userinfo, ":", parts: 2) do | |||
@@ -5,7 +5,7 @@ defmodule Pleroma.Web.FederatingPlug do | |||
options | |||
end | |||
def call(conn, opts) do | |||
def call(conn, _opts) do | |||
if Keyword.get(Application.get_env(:pleroma, :instance), :federating) do | |||
conn | |||
else | |||
@@ -4,11 +4,11 @@ defmodule Pleroma.Plugs.HTTPSecurityPlug do | |||
def init(opts), do: opts | |||
def call(conn, options) do | |||
def call(conn, _options) do | |||
if Config.get([:http_security, :enabled]) do | |||
conn = | |||
merge_resp_headers(conn, headers()) | |||
|> maybe_send_sts_header(Config.get([:http_security, :sts])) | |||
conn | |||
|> merge_resp_headers(headers()) | |||
|> maybe_send_sts_header(Config.get([:http_security, :sts])) | |||
else | |||
conn | |||
end | |||
@@ -42,7 +42,7 @@ defmodule Pleroma.Plugs.HTTPSecurityPlug do | |||
"script-src 'self'", | |||
"connect-src 'self' " <> String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws"), | |||
"manifest-src 'self'", | |||
if @protocol == "https" do | |||
if protocol == "https" do | |||
"upgrade-insecure-requests" | |||
end | |||
] | |||
@@ -1,6 +1,5 @@ | |||
defmodule Pleroma.Plugs.SessionAuthenticationPlug do | |||
import Plug.Conn | |||
alias Pleroma.User | |||
def init(options) do | |||
options | |||
@@ -8,10 +8,6 @@ defmodule Pleroma.Plugs.UploadedMedia do | |||
@behaviour Plug | |||
# no slashes | |||
@path "media" | |||
@cache_control %{ | |||
default: "public, max-age=1209600", | |||
error: "public, must-revalidate, max-age=160" | |||
} | |||
def init(_opts) do | |||
static_plug_opts = | |||
@@ -7,7 +7,7 @@ defmodule Pleroma.Plugs.UserFetcherPlug do | |||
options | |||
end | |||
def call(conn, options) do | |||
def call(conn, _options) do | |||
with %{auth_credentials: %{username: username}} <- conn.assigns, | |||
{:ok, %User{} = user} <- user_fetcher(username) do | |||
conn | |||
@@ -85,7 +85,9 @@ defmodule Pleroma.ReverseProxy do | |||
| {:redirect_on_failure, boolean()} | |||
@spec call(Plug.Conn.t(), url :: String.t(), [option()]) :: Plug.Conn.t() | |||
def call(conn = %{method: method}, url, opts \\ []) when method in @methods do | |||
def call(_conn, _url, _opts \\ []) | |||
def call(conn = %{method: method}, url, opts) when method in @methods do | |||
hackney_opts = | |||
@default_hackney_options | |||
|> Keyword.merge(Keyword.get(opts, :http, [])) | |||
@@ -240,24 +242,23 @@ defmodule Pleroma.ReverseProxy do | |||
end | |||
defp build_req_headers(headers, opts) do | |||
headers = | |||
headers | |||
|> downcase_headers() | |||
|> Enum.filter(fn {k, _} -> k in @keep_req_headers end) | |||
|> (fn headers -> | |||
headers = headers ++ Keyword.get(opts, :req_headers, []) | |||
if Keyword.get(opts, :keep_user_agent, false) do | |||
List.keystore( | |||
headers, | |||
"user-agent", | |||
0, | |||
{"user-agent", Pleroma.Application.user_agent()} | |||
) | |||
else | |||
headers | |||
end | |||
end).() | |||
headers | |||
|> downcase_headers() | |||
|> Enum.filter(fn {k, _} -> k in @keep_req_headers end) | |||
|> (fn headers -> | |||
headers = headers ++ Keyword.get(opts, :req_headers, []) | |||
if Keyword.get(opts, :keep_user_agent, false) do | |||
List.keystore( | |||
headers, | |||
"user-agent", | |||
0, | |||
{"user-agent", Pleroma.Application.user_agent()} | |||
) | |||
else | |||
headers | |||
end | |||
end).() | |||
end | |||
defp build_resp_headers(headers, opts) do | |||
@@ -268,7 +269,7 @@ defmodule Pleroma.ReverseProxy do | |||
|> (fn headers -> headers ++ Keyword.get(opts, :resp_headers, []) end).() | |||
end | |||
defp build_resp_cache_headers(headers, opts) do | |||
defp build_resp_cache_headers(headers, _opts) do | |||
has_cache? = Enum.any?(headers, fn {k, _} -> k in @resp_cache_headers end) | |||
if has_cache? do | |||
@@ -128,19 +128,18 @@ defmodule Pleroma.Upload do | |||
opts | |||
end | |||
opts = | |||
if Pleroma.Config.get([:instance, :dedupe_media]) == true && | |||
!Enum.member?(opts.filters, Pleroma.Upload.Filter.Dedupe) do | |||
Logger.warn(""" | |||
Pleroma: configuration `:instance, :dedupe_media` is deprecated, please instead set: | |||
if Pleroma.Config.get([:instance, :dedupe_media]) == true && | |||
!Enum.member?(opts.filters, Pleroma.Upload.Filter.Dedupe) do | |||
Logger.warn(""" | |||
Pleroma: configuration `:instance, :dedupe_media` is deprecated, please instead set: | |||
:pleroma, Pleroma.Upload, [filters: [Pleroma.Upload.Filter.Dedupe]] | |||
""") | |||
:pleroma, Pleroma.Upload, [filters: [Pleroma.Upload.Filter.Dedupe]] | |||
""") | |||
Map.put(opts, :filters, opts.filters ++ [Pleroma.Upload.Filter.Dedupe]) | |||
else | |||
opts | |||
end | |||
Map.put(opts, :filters, opts.filters ++ [Pleroma.Upload.Filter.Dedupe]) | |||
else | |||
opts | |||
end | |||
end | |||
defp prepare_upload(%Plug.Upload{} = file, opts) do | |||
@@ -215,8 +214,4 @@ defmodule Pleroma.Upload do | |||
[base_url, "media", path] | |||
|> Path.join() | |||
end | |||
defp url_from_spec({:url, url}) do | |||
url | |||
end | |||
end |
@@ -1,7 +1,7 @@ | |||
defmodule Pleroma.Upload.Filter.Dedupe do | |||
@behaviour Pleroma.Upload.Filter | |||
def filter(upload = %Pleroma.Upload{name: name, tempfile: path}) do | |||
def filter(upload = %Pleroma.Upload{name: name, tempfile: _path}) do | |||
extension = String.split(name, ".") |> List.last() | |||
shasum = :crypto.hash(:sha256, File.read!(upload.tempfile)) |> Base.encode16(case: :lower) | |||
filename = shasum <> "." <> extension | |||
@@ -1,5 +1,5 @@ | |||
defmodule Pleroma.Upload.Filter.Mogrify do | |||
@behaviour Pleroma.Uploader.Filter | |||
@behaviour Pleroma.Upload.Filter | |||
@type conversion :: action :: String.t() | {action :: String.t(), opts :: String.t()} | |||
@type conversions :: conversion() | [conversion()] | |||
@@ -1,8 +1,6 @@ | |||
defmodule Pleroma.Uploaders.Local do | |||
@behaviour Pleroma.Uploaders.Uploader | |||
alias Pleroma.Web | |||
def get_file(_) do | |||
{:ok, {:static_dir, upload_path()}} | |||
end | |||
@@ -12,8 +12,8 @@ defmodule Pleroma.Uploaders.MDII do | |||
end | |||
def put_file(upload) do | |||
cgi = Pleroma.Config.get([Pleroma.Uploaders.MDII, :cgi]) | |||
files = Pleroma.Config.get([Pleroma.Uploaders.MDII, :files]) | |||
cgi = Config.get([Pleroma.Uploaders.MDII, :cgi]) | |||
files = Config.get([Pleroma.Uploaders.MDII, :files]) | |||
{:ok, file_data} = File.read(upload.tempfile) | |||
@@ -9,7 +9,6 @@ defmodule Pleroma.Uploaders.Swift.Client do | |||
end | |||
def upload_file(filename, body, content_type) do | |||
object_url = Pleroma.Config.get!([Pleroma.Uploaders.Swift, :object_url]) | |||
token = Pleroma.Uploaders.Swift.Keystone.get_token() | |||
case put("#{filename}", body, "X-Auth-Token": token, "Content-Type": content_type) do | |||
@@ -2,7 +2,6 @@ defmodule Pleroma.User do | |||
use Ecto.Schema | |||
import Ecto.{Changeset, Query} | |||
alias Ecto.Multi | |||
alias Pleroma.{Repo, User, Object, Web, Activity, Notification} | |||
alias Comeonin.Pbkdf2 | |||
alias Pleroma.Formatter | |||
@@ -10,6 +9,8 @@ defmodule Pleroma.User do | |||
alias Pleroma.Web.{OStatus, Websub, OAuth} | |||
alias Pleroma.Web.ActivityPub.{Utils, ActivityPub} | |||
@type t :: %__MODULE__{} | |||
schema "users" do | |||
field(:bio, :string) | |||
field(:email, :string) | |||
@@ -218,7 +219,7 @@ defmodule Pleroma.User do | |||
end | |||
end | |||
def maybe_follow(%User{} = follower, %User{info: info} = followed) do | |||
def maybe_follow(%User{} = follower, %User{info: _info} = followed) do | |||
if not following?(follower, followed) do | |||
follow(follower, followed) | |||
else | |||
@@ -280,6 +281,7 @@ defmodule Pleroma.User do | |||
end | |||
end | |||
@spec following?(User.t(), User.t()) :: boolean | |||
def following?(%User{} = follower, %User{} = followed) do | |||
Enum.member?(follower.following, followed.follower_address) | |||
end | |||
@@ -824,20 +826,21 @@ defmodule Pleroma.User do | |||
end) | |||
end | |||
def tag(nickname, tags) when is_binary(nickname), | |||
do: tag(User.get_by_nickname(nickname), tags) | |||
def tag(%User{} = user, tags), | |||
do: update_tags(user, Enum.uniq(user.tags ++ normalize_tags(tags))) | |||
def untag(user_identifiers, tags) when is_list(user_identifiers) do | |||
Repo.transaction(fn -> | |||
for user_identifier <- user_identifiers, do: untag(user_identifier, tags) | |||
end) | |||
end | |||
def tag(nickname, tags) when is_binary(nickname), do: tag(User.get_by_nickname(nickname), tags) | |||
def untag(nickname, tags) when is_binary(nickname), | |||
do: untag(User.get_by_nickname(nickname), tags) | |||
def tag(%User{} = user, tags), | |||
do: update_tags(user, Enum.uniq(user.tags ++ normalize_tags(tags))) | |||
def untag(%User{} = user, tags), do: update_tags(user, user.tags -- normalize_tags(tags)) | |||
defp update_tags(%User{} = user, new_tags) do | |||
@@ -3,7 +3,8 @@ defmodule Pleroma.UserInviteToken do | |||
import Ecto.Changeset | |||
alias Pleroma.{User, UserInviteToken, Repo} | |||
alias Pleroma.UserInviteToken | |||
alias Pleroma.Repo | |||
schema "user_invite_tokens" do | |||
field(:token, :string) | |||
@@ -799,7 +799,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPub do | |||
end | |||
# guard | |||
def entire_thread_visible_for_user?(nil, user), do: false | |||
def entire_thread_visible_for_user?(nil, _user), do: false | |||
# child | |||
def entire_thread_visible_for_user?( | |||
@@ -141,7 +141,7 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do | |||
json(conn, "error") | |||
end | |||
def relay(conn, params) do | |||
def relay(conn, _params) do | |||
with %User{} = user <- Relay.get_actor(), | |||
{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do | |||
conn | |||
@@ -5,7 +5,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.EnsureRePrepended do | |||
@reply_prefix Regex.compile!("^re:[[:space:]]*", [:caseless]) | |||
def filter_by_summary( | |||
%{"summary" => parent_summary} = parent, | |||
%{"summary" => parent_summary} = _parent, | |||
%{"summary" => child_summary} = child | |||
) | |||
when not is_nil(child_summary) and byte_size(child_summary) > 0 and | |||
@@ -19,7 +19,7 @@ defmodule Pleroma.Web.ActivityPub.MRF.EnsureRePrepended do | |||
end | |||
end | |||
def filter_by_summary(parent, child), do: child | |||
def filter_by_summary(_parent, child), do: child | |||
def filter(%{"type" => activity_type} = object) when activity_type == "Create" do | |||
child = object["object"] | |||
@@ -37,9 +37,9 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
@doc """ | |||
Checks that an imported AP object's actor matches the domain it came from. | |||
""" | |||
def contain_origin(id, %{"actor" => nil}), do: :error | |||
def contain_origin(_id, %{"actor" => nil}), do: :error | |||
def contain_origin(id, %{"actor" => actor} = params) do | |||
def contain_origin(id, %{"actor" => _actor} = params) do | |||
id_uri = URI.parse(id) | |||
actor_uri = URI.parse(get_actor(params)) | |||
@@ -50,9 +50,9 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
end | |||
end | |||
def contain_origin_from_id(id, %{"id" => nil}), do: :error | |||
def contain_origin_from_id(_id, %{"id" => nil}), do: :error | |||
def contain_origin_from_id(id, %{"id" => other_id} = params) do | |||
def contain_origin_from_id(id, %{"id" => other_id} = _params) do | |||
id_uri = URI.parse(id) | |||
other_uri = URI.parse(other_id) | |||
@@ -266,6 +266,32 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
def fix_content_map(object), do: object | |||
defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do | |||
with true <- id =~ "follows", | |||
%User{local: true} = follower <- User.get_cached_by_ap_id(follower_id), | |||
%Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do | |||
{:ok, activity} | |||
else | |||
_ -> {:error, nil} | |||
end | |||
end | |||
defp mastodon_follow_hack(_, _), do: {:error, nil} | |||
defp get_follow_activity(follow_object, followed) do | |||
with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object), | |||
{_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do | |||
{:ok, activity} | |||
else | |||
# Can't find the activity. This might a Mastodon 2.3 "Accept" | |||
{:activity, nil} -> | |||
mastodon_follow_hack(follow_object, followed) | |||
_ -> | |||
{:error, nil} | |||
end | |||
end | |||
# disallow objects with bogus IDs | |||
def handle_incoming(%{"id" => nil}), do: :error | |||
def handle_incoming(%{"id" => ""}), do: :error | |||
@@ -331,34 +357,8 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
end | |||
end | |||
defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do | |||
with true <- id =~ "follows", | |||
%User{local: true} = follower <- User.get_cached_by_ap_id(follower_id), | |||
%Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do | |||
{:ok, activity} | |||
else | |||
_ -> {:error, nil} | |||
end | |||
end | |||
defp mastodon_follow_hack(_), do: {:error, nil} | |||
defp get_follow_activity(follow_object, followed) do | |||
with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object), | |||
{_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do | |||
{:ok, activity} | |||
else | |||
# Can't find the activity. This might a Mastodon 2.3 "Accept" | |||
{:activity, nil} -> | |||
mastodon_follow_hack(follow_object, followed) | |||
_ -> | |||
{:error, nil} | |||
end | |||
end | |||
def handle_incoming( | |||
%{"type" => "Accept", "object" => follow_object, "actor" => actor, "id" => id} = data | |||
%{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data | |||
) do | |||
with actor <- get_actor(data), | |||
%User{} = followed <- User.get_or_fetch_by_ap_id(actor), | |||
@@ -374,7 +374,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
local: false | |||
}) do | |||
if not User.following?(follower, followed) do | |||
{:ok, follower} = User.follow(follower, followed) | |||
{:ok, _follower} = User.follow(follower, followed) | |||
end | |||
{:ok, activity} | |||
@@ -384,7 +384,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
end | |||
def handle_incoming( | |||
%{"type" => "Reject", "object" => follow_object, "actor" => actor, "id" => id} = data | |||
%{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data | |||
) do | |||
with actor <- get_actor(data), | |||
%User{} = followed <- User.get_or_fetch_by_ap_id(actor), | |||
@@ -408,7 +408,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
end | |||
def handle_incoming( | |||
%{"type" => "Like", "object" => object_id, "actor" => actor, "id" => id} = data | |||
%{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data | |||
) do | |||
with actor <- get_actor(data), | |||
%User{} = actor <- User.get_or_fetch_by_ap_id(actor), | |||
@@ -421,7 +421,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
end | |||
def handle_incoming( | |||
%{"type" => "Announce", "object" => object_id, "actor" => actor, "id" => id} = data | |||
%{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data | |||
) do | |||
with actor <- get_actor(data), | |||
%User{} = actor <- User.get_or_fetch_by_ap_id(actor), | |||
@@ -492,7 +492,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
%{ | |||
"type" => "Undo", | |||
"object" => %{"type" => "Announce", "object" => object_id}, | |||
"actor" => actor, | |||
"actor" => _actor, | |||
"id" => id | |||
} = data | |||
) do | |||
@@ -520,7 +520,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
User.unfollow(follower, followed) | |||
{:ok, activity} | |||
else | |||
e -> :error | |||
_e -> :error | |||
end | |||
end | |||
@@ -539,12 +539,12 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
User.unblock(blocker, blocked) | |||
{:ok, activity} | |||
else | |||
e -> :error | |||
_e -> :error | |||
end | |||
end | |||
def handle_incoming( | |||
%{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = data | |||
%{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data | |||
) do | |||
with true <- Pleroma.Config.get([:activitypub, :accept_blocks]), | |||
%User{local: true} = blocked = User.get_cached_by_ap_id(blocked), | |||
@@ -554,7 +554,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
User.block(blocker, blocked) | |||
{:ok, activity} | |||
else | |||
e -> :error | |||
_e -> :error | |||
end | |||
end | |||
@@ -562,7 +562,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
%{ | |||
"type" => "Undo", | |||
"object" => %{"type" => "Like", "object" => object_id}, | |||
"actor" => actor, | |||
"actor" => _actor, | |||
"id" => id | |||
} = data | |||
) do | |||
@@ -292,7 +292,7 @@ defmodule Pleroma.Web.ActivityPub.Utils do | |||
""" | |||
def make_follow_data( | |||
%User{ap_id: follower_id}, | |||
%User{ap_id: followed_id} = followed, | |||
%User{ap_id: followed_id} = _followed, | |||
activity_id | |||
) do | |||
data = %{ | |||
@@ -66,10 +66,15 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIController do | |||
Ecto.Changeset.change(user) | |||
|> Ecto.Changeset.put_embed(:info, info_cng) | |||
{:ok, user} = User.update_and_set_cache(cng) | |||
{:ok, _user} = User.update_and_set_cache(cng) | |||
json(conn, info) | |||
end | |||
def right_add(conn, _) do | |||
conn | |||
|> json(info) | |||
|> put_status(404) | |||
|> json(%{error: "No such permission_group"}) | |||
end | |||
def right_get(conn, %{"nickname" => nickname}) do | |||
@@ -82,12 +87,6 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIController do | |||
}) | |||
end | |||
def right_add(conn, _) do | |||
conn | |||
|> put_status(404) | |||
|> json(%{error: "No such permission_group"}) | |||
end | |||
def right_delete( | |||
%{assigns: %{user: %User{:nickname => admin_nickname}}} = conn, | |||
%{ | |||
@@ -113,10 +112,9 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIController do | |||
Ecto.Changeset.change(user) | |||
|> Ecto.Changeset.put_embed(:info, info_cng) | |||
{:ok, user} = User.update_and_set_cache(cng) | |||
{:ok, _user} = User.update_and_set_cache(cng) | |||
conn | |||
|> json(info) | |||
json(conn, info) | |||
end | |||
end | |||
@@ -127,32 +125,28 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIController do | |||
end | |||
def relay_follow(conn, %{"relay_url" => target}) do | |||
{status, message} = Relay.follow(target) | |||
if status == :ok do | |||
conn | |||
|> json(target) | |||
with {:ok, _message} <- Relay.follow(target) do | |||
json(conn, target) | |||
else | |||
conn | |||
|> put_status(500) | |||
|> json(target) | |||
_ -> | |||
conn | |||
|> put_status(500) | |||
|> json(target) | |||
end | |||
end | |||
def relay_unfollow(conn, %{"relay_url" => target}) do | |||
{status, message} = Relay.unfollow(target) | |||
if status == :ok do | |||
conn | |||
|> json(target) | |||
with {:ok, _message} <- Relay.unfollow(target) do | |||
json(conn, target) | |||
else | |||
conn | |||
|> put_status(500) | |||
|> json(target) | |||
_ -> | |||
conn | |||
|> put_status(500) | |||
|> json(target) | |||
end | |||
end | |||
@shortdoc "Get a account registeration invite token (base64 string)" | |||
@doc "Get a account registeration invite token (base64 string)" | |||
def get_invite_token(conn, _params) do | |||
{:ok, token} = Pleroma.UserInviteToken.create_token() | |||
@@ -160,7 +154,7 @@ defmodule Pleroma.Web.AdminAPI.AdminAPIController do | |||
|> json(token.token) | |||
end | |||
@shortdoc "Get a password reset token (base64 string) for given nickname" | |||
@doc "Get a password reset token (base64 string) for given nickname" | |||
def get_password_reset(conn, %{"nickname" => nickname}) do | |||
(%User{local: true} = user) = User.get_by_nickname(nickname) | |||
{:ok, token} = Pleroma.PasswordResetToken.create_token(user) | |||
@@ -122,7 +122,7 @@ defmodule Pleroma.Web.CommonAPI.Utils do | |||
|> Formatter.finalize() | |||
end | |||
def format_input(text, mentions, tags, "text/html") do | |||
def format_input(text, mentions, _tags, "text/html") do | |||
text | |||
|> Formatter.html_escape("text/html") | |||
|> String.replace(~r/\r?\n/, "<br>") | |||
@@ -236,7 +236,7 @@ defmodule Pleroma.Web.CommonAPI.Utils do | |||
end | |||
end | |||
def emoji_from_profile(%{info: info} = user) do | |||
def emoji_from_profile(%{info: _info} = user) do | |||
(Formatter.get_emoji(user.bio) ++ Formatter.get_emoji(user.name)) | |||
|> Enum.map(fn {shortcode, url} -> | |||
%{ | |||
@@ -13,7 +13,6 @@ defmodule Pleroma.Web.Federator do | |||
@websub Application.get_env(:pleroma, :websub) | |||
@ostatus Application.get_env(:pleroma, :ostatus) | |||
@httpoison Application.get_env(:pleroma, :httpoison) | |||
@max_jobs 20 | |||
def init(args) do | |||
@@ -134,7 +133,7 @@ defmodule Pleroma.Web.Federator do | |||
def handle( | |||
:publish_single_websub, | |||
%{xml: xml, topic: topic, callback: callback, secret: secret} = params | |||
%{xml: _xml, topic: _topic, callback: _callback, secret: _secret} = params | |||
) do | |||
case Websub.publish_one(params) do | |||
{:ok, _} -> | |||
@@ -1,13 +1,8 @@ | |||
defmodule Pleroma.Web.Federator.RetryQueue do | |||
use GenServer | |||
alias Pleroma.Web.{WebFinger, Websub} | |||
alias Pleroma.Web.ActivityPub.ActivityPub | |||
require Logger | |||
@websub Application.get_env(:pleroma, :websub) | |||
@ostatus Application.get_env(:pleroma, :websub) | |||
@httpoison Application.get_env(:pleroma, :websub) | |||
@instance Application.get_env(:pleroma, :websub) | |||
# initial timeout, 5 min | |||
@initial_timeout 30_000 | |||
@max_retries 5 | |||
@@ -42,7 +37,7 @@ defmodule Pleroma.Web.Federator.RetryQueue do | |||
def handle_cast({:maybe_enqueue, data, transport, retries}, %{dropped: drop_count} = state) do | |||
case get_retry_params(retries) do | |||
{:retry, timeout} -> | |||
{:retry, _timeout} -> | |||
Process.send_after( | |||
__MODULE__, | |||
{:send, data, transport, retries}, | |||
@@ -62,7 +57,7 @@ defmodule Pleroma.Web.Federator.RetryQueue do | |||
{:ok, _} -> | |||
{:noreply, %{state | delivered: delivery_count + 1}} | |||
{:error, reason} -> | |||
{:error, _reason} -> | |||
enqueue(data, transport, retries) | |||
{:noreply, state} | |||
end | |||
@@ -437,10 +437,7 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do | |||
end | |||
# Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array. | |||
def relationships(%{assigns: %{user: user}} = conn, _) do | |||
conn | |||
|> json([]) | |||
end | |||
def relationships(%{assigns: %{user: _user}} = conn, _), do: json(conn, []) | |||
def update_media(%{assigns: %{user: user}} = conn, data) do | |||
with %Object{} = object <- Repo.get(Object, data["id"]), | |||
@@ -850,7 +847,7 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do | |||
end | |||
def list_timeline(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params) do | |||
with %Pleroma.List{title: title, following: following} <- Pleroma.List.get(id, user) do | |||
with %Pleroma.List{title: _title, following: following} <- Pleroma.List.get(id, user) do | |||
params = | |||
params | |||
|> Map.put("type", "Create") | |||
@@ -983,13 +980,11 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do | |||
with changeset <- User.update_changeset(user), | |||
changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng), | |||
{:ok, user} <- User.update_and_set_cache(changeset) do | |||
conn | |||
|> json(%{}) | |||
{:ok, _user} <- User.update_and_set_cache(changeset) do | |||
json(conn, %{}) | |||
else | |||
e -> | |||
conn | |||
|> json(%{error: inspect(e)}) | |||
json(conn, %{error: inspect(e)}) | |||
end | |||
end | |||
@@ -5,7 +5,7 @@ defmodule Pleroma.Web.MastodonAPI.MastodonSocket do | |||
alias Pleroma.{User, Repo} | |||
transport( | |||
:streaming, | |||
:websocket, | |||
Phoenix.Transports.WebSocket.Raw, | |||
# We never receive data. | |||
timeout: :infinity | |||
@@ -52,13 +52,9 @@ defmodule Pleroma.Web.MastodonAPI.MastodonSocket do | |||
_ -> stream | |||
end | |||
with socket = | |||
socket | |||
|> assign(:topic, topic) do | |||
with socket <- assign(socket, :topic, topic) do | |||
Pleroma.Web.Streamer.add_socket(topic, socket) | |||
{:ok, socket} | |||
else | |||
_e -> :error | |||
end | |||
end | |||
@@ -1,5 +1,4 @@ | |||
defmodule Pleroma.Web.MastodonAPI.MastodonView do | |||
use Pleroma.Web, :view | |||
import Phoenix.HTML | |||
import Phoenix.HTML.Form | |||
end |
@@ -1,6 +1,5 @@ | |||
defmodule Pleroma.Web.MastodonAPI.PushSubscriptionView do | |||
use Pleroma.Web, :view | |||
alias Pleroma.Web.MastodonAPI.PushSubscriptionView | |||
def render("push_subscription.json", %{subscription: subscription}) do | |||
%{ | |||
@@ -8,7 +8,7 @@ defmodule Pleroma.Web.MediaProxy.MediaProxyController do | |||
with config <- Pleroma.Config.get([:media_proxy], []), | |||
true <- Keyword.get(config, :enabled, false), | |||
{:ok, url} <- MediaProxy.decode_url(sig64, url64), | |||
filename <- Path.basename(URI.parse(url).path), | |||
_filename <- Path.basename(URI.parse(url).path), | |||
:ok <- filename_matches(Map.has_key?(params, "filename"), conn.request_path, url) do | |||
ReverseProxy.call(conn, url, Keyword.get(config, :proxy_opts, @default_proxy_opts)) | |||
else | |||
@@ -121,7 +121,7 @@ defmodule Pleroma.Web.OAuth.OAuthController do | |||
def token_exchange( | |||
conn, | |||
%{"grant_type" => "password", "name" => name, "password" => password} = params | |||
%{"grant_type" => "password", "name" => name, "password" => _password} = params | |||
) do | |||
params = | |||
params | |||
@@ -376,7 +376,7 @@ defmodule Pleroma.Web.OStatus do | |||
def fetch_activity_from_url(url) do | |||
try do | |||
with {:ok, activities} when length(activities) > 0 <- fetch_activity_from_atom_url(url) do | |||
with {:ok, activities} when activities != [] <- fetch_activity_from_atom_url(url) do | |||
{:ok, activities} | |||
else | |||
_e -> | |||
@@ -157,7 +157,7 @@ defmodule Pleroma.Web.OStatus.OStatusController do | |||
conn, | |||
"activity+json", | |||
%Activity{data: %{"type" => "Create"}} = activity, | |||
user | |||
_user | |||
) do | |||
object = Object.normalize(activity.data["object"]) | |||
@@ -166,7 +166,7 @@ defmodule Pleroma.Web.OStatus.OStatusController do | |||
|> json(ObjectView.render("object.json", %{object: object})) | |||
end | |||
defp represent_activity(conn, "activity+json", _, _) do | |||
defp represent_activity(_conn, "activity+json", _, _) do | |||
{:error, :not_found} | |||
end | |||
@@ -1,8 +1,6 @@ | |||
defmodule Pleroma.Web.Router do | |||
use Pleroma.Web, :router | |||
alias Pleroma.{Repo, User, Web.Router} | |||
pipeline :api do | |||
plug(:accepts, ["json"]) | |||
plug(:fetch_session) | |||
@@ -61,8 +61,6 @@ defmodule Pleroma.Web.Streamer do | |||
end | |||
def handle_cast(%{action: :stream, topic: "list", item: item}, topics) do | |||
author = User.get_cached_by_ap_id(item.data["actor"]) | |||
# filter the recipient list if the activity is not public, see #270. | |||
recipient_lists = | |||
case ActivityPub.is_public?(item) do | |||
@@ -6,9 +6,8 @@ defmodule Pleroma.Web.TwitterAPI.UtilController do | |||
alias Pleroma.Web.WebFinger | |||
alias Pleroma.Web.CommonAPI | |||
alias Comeonin.Pbkdf2 | |||
alias Pleroma.{Formatter, Emoji} | |||
alias Pleroma.Web.ActivityPub.ActivityPub | |||
alias Pleroma.{Repo, PasswordResetToken, User} | |||
alias Pleroma.{Repo, PasswordResetToken, User, Emoji} | |||
def show_password_reset(conn, %{"token" => token}) do | |||
with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}), | |||
@@ -141,7 +141,7 @@ defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter do | |||
end | |||
def to_map( | |||
%Activity{data: %{"object" => %{"content" => content} = object}} = activity, | |||
%Activity{data: %{"object" => %{"content" => _content} = object}} = activity, | |||
%{user: user} = opts | |||
) do | |||
created_at = object["published"] |> Utils.date_to_asctime() | |||
@@ -165,7 +165,7 @@ defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter do | |||
tags = if possibly_sensitive, do: Enum.uniq(["nsfw" | tags]), else: tags | |||
{summary, content} = ActivityView.render_content(object) | |||
{_summary, content} = ActivityView.render_content(object) | |||
html = | |||
HTML.filter_tags(content, User.html_filter_policy(opts[:for])) | |||
@@ -173,7 +173,7 @@ defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter do | |||
video = | |||
if object["type"] == "Video" do | |||
vid = [object] | |||
[object] | |||
else | |||
[] | |||
end | |||
@@ -2,18 +2,15 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPI do | |||
alias Pleroma.{UserInviteToken, User, Activity, Repo, Object} | |||
alias Pleroma.Web.ActivityPub.ActivityPub | |||
alias Pleroma.Web.TwitterAPI.UserView | |||
alias Pleroma.Web.{OStatus, CommonAPI} | |||
alias Pleroma.Web.MediaProxy | |||
alias Pleroma.Web.CommonAPI | |||
import Ecto.Query | |||
@httpoison Application.get_env(:pleroma, :httpoison) | |||
def create_status(%User{} = user, %{"status" => _} = data) do | |||
CommonAPI.post(user, data) | |||
end | |||
def delete(%User{} = user, id) do | |||
with %Activity{data: %{"type" => type}} <- Repo.get(Activity, id), | |||
with %Activity{data: %{"type" => _type}} <- Repo.get(Activity, id), | |||
{:ok, activity} <- CommonAPI.delete(id, user) do | |||
{:ok, activity} | |||
end | |||
@@ -37,7 +34,7 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPI do | |||
def unfollow(%User{} = follower, params) do | |||
with {:ok, %User{} = unfollowed} <- get_user(params), | |||
{:ok, follower, follow_activity} <- User.unfollow(follower, unfollowed), | |||
{:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed), | |||
{:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed) do | |||
{:ok, follower, unfollowed} | |||
else | |||
@@ -244,10 +241,6 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPI do | |||
_activities = Repo.all(q) | |||
end | |||
defp make_date do | |||
DateTime.utc_now() |> DateTime.to_iso8601() | |||
end | |||
# DEPRECATED mostly, context objects are now created at insertion time. | |||
def context_to_conversation_id(context) do | |||
with %Object{id: id} <- Object.get_cached_by_ap_id(context) do | |||
@@ -1,9 +1,7 @@ | |||
defmodule Pleroma.Web.TwitterAPI.Controller do | |||
use Pleroma.Web, :controller | |||
alias Pleroma.Formatter | |||
alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView, ActivityView, NotificationView} | |||
alias Pleroma.Web.CommonAPI | |||
alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils | |||
alias Pleroma.{Repo, Activity, Object, User, Notification} | |||
alias Pleroma.Web.ActivityPub.ActivityPub | |||
alias Pleroma.Web.ActivityPub.Utils | |||
@@ -155,7 +153,7 @@ defmodule Pleroma.Web.TwitterAPI.Controller do | |||
|> render(NotificationView, "notification.json", %{notifications: notifications, for: user}) | |||
end | |||
def notifications_read(%{assigns: %{user: user}} = conn, _) do | |||
def notifications_read(%{assigns: %{user: _user}} = conn, _) do | |||
bad_request_reply(conn, "You need to specify latest_id") | |||
end | |||
@@ -416,7 +414,7 @@ defmodule Pleroma.Web.TwitterAPI.Controller do | |||
end | |||
end | |||
def approve_friend_request(conn, %{"user_id" => uid} = params) do | |||
def approve_friend_request(conn, %{"user_id" => uid} = _params) do | |||
with followed <- conn.assigns[:user], | |||
uid when is_number(uid) <- String.to_integer(uid), | |||
%User{} = follower <- Repo.get(User, uid), | |||
@@ -436,7 +434,7 @@ defmodule Pleroma.Web.TwitterAPI.Controller do | |||
end | |||
end | |||
def deny_friend_request(conn, %{"user_id" => uid} = params) do | |||
def deny_friend_request(conn, %{"user_id" => uid} = _params) do | |||
with followed <- conn.assigns[:user], | |||
uid when is_number(uid) <- String.to_integer(uid), | |||
%User{} = follower <- Repo.get(User, uid), | |||
@@ -28,12 +28,12 @@ defmodule Pleroma.Web.XML do | |||
|> :xmerl_scan.string() | |||
doc | |||
catch | |||
:exit, _error -> | |||
rescue | |||
_e -> | |||
Logger.debug("Couldn't parse XML: #{inspect(text)}") | |||
:error | |||
rescue | |||
e -> | |||
catch | |||
:exit, _error -> | |||
Logger.debug("Couldn't parse XML: #{inspect(text)}") | |||
:error | |||
end | |||