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
defmodule Mix.Tasks.Pleroma.Instance do
use Mix.Task
- alias Pleroma.{Repo, User}
alias Mix.Tasks.Pleroma.Common
@shortdoc "Manages Pleroma instance"
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
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
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()
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 ->
- `--admin`/`--no-admin` - whether the user is an admin
## Generate an invite link.
-
+
mix pleroma.user invite
## Delete the user's account.
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.
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})
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
# 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
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}
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)
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,
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(
{"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 =
{"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
# fetch Hackney options
#
- defp hackney_options(opts \\ []) do
+ defp hackney_options(opts) do
options = Keyword.get(opts, :adapter, [])
@hackney_options ++ options
end
|> validate_required([:following])
end
- def for_user(user, opts) do
+ def for_user(user, _opts) do
query =
from(
l in Pleroma.List,
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,
{: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, ".")
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
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"])
end
end
- def call(
- %{
- assigns: %{
- auth_credentials: %{password: password}
- }
- } = conn,
- _
- ) do
+ def call(%{assigns: %{auth_credentials: %{password: _}}} = conn, _) do
Pbkdf2.dummy_checkpw()
conn
end
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
options
end
- def call(conn, opts) do
+ def call(conn, _opts) do
if Keyword.get(Application.get_env(:pleroma, :instance), :federating) do
conn
else
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
"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
]
defmodule Pleroma.Plugs.SessionAuthenticationPlug do
import Plug.Conn
- alias Pleroma.User
def init(options) do
options
@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 =
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
| {: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, []))
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
|> (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
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
[base_url, "media", path]
|> Path.join()
end
-
- defp url_from_spec({:url, url}) do
- url
- end
end
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
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()]
defmodule Pleroma.Uploaders.Local do
@behaviour Pleroma.Uploaders.Uploader
- alias Pleroma.Web
-
def get_file(_) do
{:ok, {:static_dir, upload_path()}}
end
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)
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
use Ecto.Schema
import Ecto.{Changeset, Query}
- alias Ecto.Multi
alias Pleroma.{Repo, User, Object, Web, Activity, Notification}
alias Comeonin.Pbkdf2
alias Pleroma.Formatter
alias Pleroma.Web.{OStatus, Websub, OAuth}
alias Pleroma.Web.ActivityPub.{Utils, ActivityPub}
+ @type t :: %__MODULE__{}
+
schema "users" do
field(:bio, :string)
field(:email, :string)
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
end
end
+ @spec following?(User.t(), User.t()) :: boolean
def following?(%User{} = follower, %User{} = followed) do
Enum.member?(follower.following, followed.follower_address)
end
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
import Ecto.Changeset
- alias Pleroma.{User, UserInviteToken, Repo}
+ alias Pleroma.UserInviteToken
+ alias Pleroma.Repo
schema "user_invite_tokens" do
field(:token, :string)
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?(
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
@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
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"]
@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))
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)
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
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),
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}
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),
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),
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),
%{
"type" => "Undo",
"object" => %{"type" => "Announce", "object" => object_id},
- "actor" => actor,
+ "actor" => _actor,
"id" => id
} = data
) do
User.unfollow(follower, followed)
{:ok, activity}
else
- e -> :error
+ _e -> :error
end
end
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),
User.block(blocker, blocked)
{:ok, activity}
else
- e -> :error
+ _e -> :error
end
end
%{
"type" => "Undo",
"object" => %{"type" => "Like", "object" => object_id},
- "actor" => actor,
+ "actor" => _actor,
"id" => id
} = data
) 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 = %{
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
})
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,
%{
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
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()
|> 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)
|> 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>")
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} ->
%{
@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
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, _} ->
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
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},
{:ok, _} ->
{:noreply, %{state | delivered: delivery_count + 1}}
- {:error, reason} ->
+ {:error, _reason} ->
enqueue(data, transport, retries)
{:noreply, state}
end
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"]),
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")
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
alias Pleroma.{User, Repo}
transport(
- :streaming,
+ :websocket,
Phoenix.Transports.WebSocket.Raw,
# We never receive data.
timeout: :infinity
_ -> 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
defmodule Pleroma.Web.MastodonAPI.MastodonView do
use Pleroma.Web, :view
import Phoenix.HTML
- import Phoenix.HTML.Form
end
defmodule Pleroma.Web.MastodonAPI.PushSubscriptionView do
use Pleroma.Web, :view
- alias Pleroma.Web.MastodonAPI.PushSubscriptionView
def render("push_subscription.json", %{subscription: subscription}) 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
def token_exchange(
conn,
- %{"grant_type" => "password", "name" => name, "password" => password} = params
+ %{"grant_type" => "password", "name" => name, "password" => _password} = params
) do
params =
params
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 ->
conn,
"activity+json",
%Activity{data: %{"type" => "Create"}} = activity,
- user
+ _user
) do
object = Object.normalize(activity.data["object"])
|> 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
defmodule Pleroma.Web.Router do
use Pleroma.Web, :router
- alias Pleroma.{Repo, User, Web.Router}
-
pipeline :api do
plug(:accepts, ["json"])
plug(:fetch_session)
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
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}),
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()
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]))
video =
if object["type"] == "Video" do
- vid = [object]
+ [object]
else
[]
end
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
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
_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
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
|> 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
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),
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),
|> :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
projects / akkoma / commitdiff