# For some checks, like AliasUsage, you can only customize the priority
# Priority values are: `low, normal, high, higher`
- {Credo.Check.Design.AliasUsage, priority: :low},
+ {Credo.Check.Design.AliasUsage, priority: :low, if_called_more_often_than: 3},
# For others you can set parameters
{Credo.Check.Warning.BoolOperationOnSameValues},
{Credo.Check.Warning.IExPry},
{Credo.Check.Warning.IoInspect},
- {Credo.Check.Warning.LazyLogging},
+ # Got too much of them, not sure if relevant
+ {Credo.Check.Warning.LazyLogging, false},
{Credo.Check.Warning.OperationOnSameValues},
{Credo.Check.Warning.OperationWithConstantResult},
{Credo.Check.Warning.UnusedEnumOperation},
defmodule Mix.Tasks.Pleroma.Uploads do
use Mix.Task
- alias Pleroma.{Upload, Uploaders.Local}
+ alias Pleroma.Upload
+ alias Pleroma.Uploaders.Local
alias Mix.Tasks.Pleroma.Common
require Logger
- `--delete` - delete local uploads after migrating them to the target uploader
- A list of avalible uploaders can be seen in config.exs
+ A list of available uploaders can be seen in config.exs
"""
def run(["migrate_local", target_uploader | args]) do
delete? = Enum.member?(args, "--delete")
timeout: 150_000
)
|> Stream.chunk_every(@log_every)
+ # credo:disable-for-next-line Credo.Check.Warning.UnusedEnumOperation
|> Enum.reduce(0, fn done, count ->
count = count + length(done)
Mix.shell().info("Uploaded #{count}/#{total_count} files")
defmodule Mix.Tasks.Pleroma.User do
use Mix.Task
import Ecto.Changeset
- alias Pleroma.{Repo, User}
+ alias Pleroma.Repo
+ alias Pleroma.User
alias Mix.Tasks.Pleroma.Common
@shortdoc "Manages Pleroma users"
user = Repo.get(User, user.id)
- if length(user.following) == 0 do
+ if Enum.empty?(user.following) do
Mix.shell().info("Successfully unsubscribed all followers from #{user.nickname}")
end
else
import Ecto.Changeset
- alias Pleroma.{User, PasswordResetToken, Repo}
+ alias Pleroma.User
+ alias Pleroma.Repo
+ alias Pleroma.PasswordResetToken
schema "password_reset_tokens" do
belongs_to(:user, User, type: Pleroma.FlakeId)
defmodule Pleroma.Activity do
use Ecto.Schema
- alias Pleroma.{Repo, Activity, Notification}
+
+ alias Pleroma.Repo
+ alias Pleroma.Activity
+ alias Pleroma.Notification
+
import Ecto.Query
@type t :: %__MODULE__{}
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Captcha do
+ alias Calendar.DateTime
alias Plug.Crypto.KeyGenerator
alias Plug.Crypto.MessageEncryptor
- alias Calendar.DateTime
use GenServer
import Swoosh.Email
- alias Pleroma.Web.{Endpoint, Router}
+ alias Pleroma.Web.Endpoint
+ alias Pleroma.Web.Router
defp instance_config, do: Pleroma.Config.get(:instance)
defmodule Pleroma.Filter do
use Ecto.Schema
- import Ecto.{Changeset, Query}
- alias Pleroma.{User, Repo}
+
+ import Ecto.Changeset
+ import Ecto.Query
+
+ alias Pleroma.User
+ alias Pleroma.Repo
schema "filters" do
belongs_to(:user, User, type: Pleroma.FlakeId)
Kernel.to_string(id)
end
- def to_string(flake = <<_::integer-size(64), _::integer-size(48), _::integer-size(16)>>) do
+ def to_string(<<_::integer-size(64), _::integer-size(48), _::integer-size(16)>> = flake) do
encode_base62(flake)
end
def from_string(unquote(Kernel.to_string(i))), do: <<0::integer-size(128)>>
end
- def from_string(flake = <<_::integer-size(128)>>), do: flake
+ def from_string(<<_::integer-size(128)>> = flake), do: flake
def from_string(string) when is_binary(string) and byte_size(string) < 18 do
case Integer.parse(string) do
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Formatter do
+ alias Pleroma.Emoji
+ alias Pleroma.HTML
alias Pleroma.User
alias Pleroma.Web.MediaProxy
- alias Pleroma.HTML
- alias Pleroma.Emoji
@tag_regex ~r/((?<=[^&])|\A)(\#)(\w+)/u
@markdown_characters_regex ~r/(`|\*|_|{|}|[|]|\(|\)|#|\+|-|\.|!)/
defmodule Pleroma.Gopher.Server.ProtocolHandler do
alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.User
alias Pleroma.Activity
- alias Pleroma.Repo
alias Pleroma.HTML
+ alias Pleroma.User
+ alias Pleroma.Repo
def start_link(ref, socket, transport, opts) do
pid = spawn_link(__MODULE__, :init, [ref, socket, transport, opts])
{:ok, pid}
end
- def init(ref, socket, transport, _Opts = []) do
+ def init(ref, socket, transport, [] = _Opts) do
:ok = :ranch.accept_ack(ref)
loop(socket, transport)
end
"""
@markup Application.get_env(:pleroma, :markup)
- @uri_schemes Application.get_env(:pleroma, :uri_schemes, [])
- @valid_schemes Keyword.get(@uri_schemes, :valid_schemes, [])
+ @valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])
require HtmlSanitizeEx.Scrubber.Meta
alias HtmlSanitizeEx.Scrubber.Meta
require HtmlSanitizeEx.Scrubber.Meta
alias HtmlSanitizeEx.Scrubber.Meta
+ # credo:disable-for-previous-line
+ # No idea how to fix this one…
@markup Application.get_env(:pleroma, :markup)
- @uri_schemes Application.get_env(:pleroma, :uri_schemes, [])
- @valid_schemes Keyword.get(@uri_schemes, :valid_schemes, [])
+ @valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])
Meta.remove_cdata_sections_before_scrub()
Meta.strip_comments()
@moduledoc "Instance."
alias Pleroma.Instances
+ alias Pleroma.Repo
alias Pleroma.Instances.Instance
use Ecto.Schema
- import Ecto.{Query, Changeset}
-
- alias Pleroma.Repo
+ import Ecto.Query
+ import Ecto.Changeset
schema "instances" do
field(:host, :string)
defmodule Pleroma.List do
use Ecto.Schema
- import Ecto.{Changeset, Query}
- alias Pleroma.{User, Repo, Activity}
+
+ import Ecto.Query
+ import Ecto.Changeset
+
+ alias Pleroma.Activity
+ alias Pleroma.Repo
+ alias Pleroma.User
schema "lists" do
belongs_to(:user, User, type: Pleroma.FlakeId)
defmodule Pleroma.Notification do
use Ecto.Schema
- alias Pleroma.{User, Activity, Notification, Repo}
+
+ alias Pleroma.User
+ alias Pleroma.Activity
+ alias Pleroma.Notification
+ alias Pleroma.Repo
alias Pleroma.Web.CommonAPI.Utils
+
import Ecto.Query
schema "notifications" do
defmodule Pleroma.Object do
use Ecto.Schema
- alias Pleroma.{Repo, Object, User, Activity, ObjectTombstone}
- import Ecto.{Query, Changeset}
+
+ alias Pleroma.Repo
+ alias Pleroma.Object
+ alias Pleroma.User
+ alias Pleroma.Activity
+ alias Pleroma.ObjectTombstone
+
+ import Ecto.Query
+ import Ecto.Changeset
schema "objects" do
field(:data, :map)
for only <- @only do
at = Plug.Router.Utils.split("/")
- def call(conn = %{request_path: "/" <> unquote(only) <> _}, opts) do
+ def call(%{request_path: "/" <> unquote(only) <> _} = conn, opts) do
call_static(
conn,
opts,
import Plug.Conn
import Ecto.Query
- alias Pleroma.{
- User,
- Repo,
- Web.OAuth.Token
- }
+ alias Pleroma.User
+ alias Pleroma.Repo
+ alias Pleroma.Web.OAuth.Token
@realm_reg Regex.compile!("Bearer\:?\s+(.*)$", "i")
%{static_plug_opts: static_plug_opts}
end
- def call(conn = %{request_path: <<"/", @path, "/", file::binary>>}, opts) do
+ def call(%{request_path: <<"/", @path, "/", file::binary>>} = conn, opts) do
config = Pleroma.Config.get([Pleroma.Upload])
with uploader <- Keyword.fetch!(config, :uploader),
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Plugs.UserFetcherPlug do
- import Plug.Conn
- alias Pleroma.Repo
alias Pleroma.User
+ alias Pleroma.Repo
+
+ import Plug.Conn
def init(options) do
options
defmodule Pleroma.Stats do
import Ecto.Query
- alias Pleroma.{User, Repo}
+ alias Pleroma.User
+ alias Pleroma.Repo
def start_link do
agent = Agent.start_link(fn -> {[], %{}} end, name: __MODULE__)
def schedule_update do
spawn(fn ->
# 1 hour
- Process.sleep(1000 * 60 * 60 * 1)
+ Process.sleep(1000 * 60 * 60)
schedule_update()
end)
end
# For Mix.Tasks.MigrateLocalUploads
- defp prepare_upload(upload = %__MODULE__{tempfile: path}, _opts) do
+ defp prepare_upload(%__MODULE__{tempfile: path} = upload, _opts) do
with {:ok, content_type} <- Pleroma.MIME.file_mime_type(path) do
{:ok, %__MODULE__{upload | content_type: content_type}}
end
@behaviour Pleroma.Upload.Filter
alias Pleroma.Upload
- def filter(upload = %Upload{name: name}) do
+ def filter(%Upload{name: name} = upload) do
extension = String.split(name, ".") |> List.last()
shasum = :crypto.hash(:sha256, File.read!(upload.tempfile)) |> Base.encode16(case: :lower)
filename = shasum <> "." <> extension
])}}
end
- def put_file(upload = %Pleroma.Upload{}) do
+ def put_file(%Pleroma.Upload{} = upload) do
config = Pleroma.Config.get([__MODULE__])
bucket = Keyword.get(config, :bucket)
defmodule Pleroma.User do
use Ecto.Schema
- import Ecto.{Changeset, Query}
- alias Pleroma.{Repo, User, Object, Web, Activity, Notification}
+ import Ecto.Changeset
+ import Ecto.Query
+
+ alias Pleroma.Repo
+ alias Pleroma.User
+ alias Pleroma.Object
+ alias Pleroma.Web
+ alias Pleroma.Activity
+ alias Pleroma.Notification
alias Comeonin.Pbkdf2
alias Pleroma.Formatter
alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
- alias Pleroma.Web.{OStatus, Websub, OAuth}
- alias Pleroma.Web.ActivityPub.{Utils, ActivityPub}
+ alias Pleroma.Web.OStatus
+ alias Pleroma.Web.Websub
+ alias Pleroma.Web.OAuth
+ alias Pleroma.Web.ActivityPub.Utils
+ alias Pleroma.Web.ActivityPub.ActivityPub
require Logger
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.ActivityPub.ActivityPub do
- alias Pleroma.{Activity, Repo, Object, Upload, User, Notification, Instances}
- alias Pleroma.Web.ActivityPub.{Transmogrifier, MRF}
+ alias Pleroma.Activity
+ alias Pleroma.Repo
+ alias Pleroma.Object
+ alias Pleroma.Upload
+ alias Pleroma.User
+ alias Pleroma.Notification
+ alias Pleroma.Instances
+ alias Pleroma.Web.ActivityPub.Transmogrifier
+ alias Pleroma.Web.ActivityPub.MRF
alias Pleroma.Web.WebFinger
alias Pleroma.Web.Federator
alias Pleroma.Web.OStatus
+
import Ecto.Query
import Pleroma.Web.ActivityPub.Utils
+
require Logger
@httpoison Application.get_env(:pleroma, :httpoison)
defp get_recipients(%{"type" => "Announce"} = data) do
to = data["to"] || []
cc = data["cc"] || []
- recipients = to ++ cc
actor = User.get_cached_by_ap_id(data["actor"])
- recipients
- |> Enum.filter(fn recipient ->
- case User.get_cached_by_ap_id(recipient) do
- nil ->
- true
-
- user ->
- User.following?(user, actor)
- end
- end)
+ recipients =
+ (to ++ cc)
+ |> Enum.filter(fn recipient ->
+ case User.get_cached_by_ap_id(recipient) do
+ nil ->
+ true
+
+ user ->
+ User.following?(user, actor)
+ end
+ end)
{recipients, to, cc}
end
activity.data["object"]
|> Map.get("tag", [])
|> Enum.filter(fn tag -> is_bitstring(tag) end)
- |> Enum.map(fn tag -> Pleroma.Web.Streamer.stream("hashtag:" <> tag, activity) end)
+ |> Enum.each(fn tag -> Pleroma.Web.Streamer.stream("hashtag:" <> tag, activity) end)
if activity.data["object"]["attachment"] != [] do
Pleroma.Web.Streamer.stream("public:media", activity)
defmodule Pleroma.Web.ActivityPub.ActivityPubController do
use Pleroma.Web, :controller
- alias Pleroma.{Activity, User, Object}
- alias Pleroma.Web.ActivityPub.{ObjectView, UserView}
+ alias Pleroma.Activity
+ alias Pleroma.User
+ alias Pleroma.Object
+ alias Pleroma.Web.ActivityPub.ObjectView
+ alias Pleroma.Web.ActivityPub.UserView
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.ActivityPub.Relay
- alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Web.ActivityPub.Transmogrifier
+ alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Web.Federator
require Logger
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.ActivityPub.Relay do
- alias Pleroma.{User, Object, Activity}
+ alias Pleroma.User
+ alias Pleroma.Object
+ alias Pleroma.Activity
alias Pleroma.Web.ActivityPub.ActivityPub
require Logger
@moduledoc """
A module to handle coding from internal to wire ActivityPub and back.
"""
+ alias Pleroma.Activity
alias Pleroma.User
alias Pleroma.Object
- alias Pleroma.Activity
alias Pleroma.Repo
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.ActivityPub.Utils
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.ActivityPub.Utils do
- alias Pleroma.{Repo, Web, Object, Activity, User, Notification}
+ alias Pleroma.Repo
+ alias Pleroma.Web
+ alias Pleroma.Object
+ alias Pleroma.Activity
+ alias Pleroma.User
+ alias Pleroma.Notification
alias Pleroma.Web.Router.Helpers
alias Pleroma.Web.Endpoint
- alias Ecto.{Changeset, UUID}
+ alias Ecto.Changeset
+ alias Ecto.UUID
+
import Ecto.Query
+
require Logger
@supported_object_types ["Article", "Note", "Video", "Page"]
defmodule Pleroma.Web.ActivityPub.ObjectView do
use Pleroma.Web, :view
- alias Pleroma.{Object, Activity}
+ alias Pleroma.Activity
+ alias Pleroma.Object
alias Pleroma.Web.ActivityPub.Transmogrifier
def render("object.json", %{object: %Object{} = object}) do
defmodule Pleroma.Web.ActivityPub.UserView do
use Pleroma.Web, :view
- alias Pleroma.Web.Salmon
+
alias Pleroma.Web.WebFinger
+ alias Pleroma.Web.Salmon
alias Pleroma.User
alias Pleroma.Repo
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.ActivityPub.Transmogrifier
alias Pleroma.Web.ActivityPub.Utils
+
import Ecto.Query
# the instance itself is not a Person, but instead an Application
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.CommonAPI do
- alias Pleroma.{User, Repo, Activity, Object}
+ alias Pleroma.User
+ alias Pleroma.Repo
+ alias Pleroma.Activity
+ alias Pleroma.Object
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Formatter
defmodule Pleroma.Web.CommonAPI.Utils do
alias Calendar.Strftime
alias Comeonin.Pbkdf2
- alias Pleroma.{Activity, Formatter, Object, Repo}
+ alias Pleroma.Activity
+ alias Pleroma.Formatter
+ alias Pleroma.Object
+ alias Pleroma.Repo
alias Pleroma.User
alias Pleroma.Web
- alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Web.Endpoint
alias Pleroma.Web.MediaProxy
+ alias Pleroma.Web.ActivityPub.Utils
# This is a hack for twidere.
def get_by_id_or_ap_id(id) do
def make_context(%Activity{data: %{"context" => context}}), do: context
def make_context(_), do: Utils.generate_context_id()
- def maybe_add_attachments(text, _attachments, _no_links = true), do: text
+ def maybe_add_attachments(text, _attachments, true = _no_links), do: text
def maybe_add_attachments(text, attachments, _no_links) do
add_attachments(text, attachments)
defmodule Pleroma.Web.Federator do
use GenServer
- alias Pleroma.User
+
alias Pleroma.Activity
- alias Pleroma.Web.{WebFinger, Websub, Salmon}
- alias Pleroma.Web.Federator.RetryQueue
+ alias Pleroma.User
+ alias Pleroma.Web.WebFinger
+ alias Pleroma.Web.Websub
+ alias Pleroma.Web.Salmon
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.ActivityPub.Relay
alias Pleroma.Web.ActivityPub.Transmogrifier
alias Pleroma.Web.ActivityPub.Utils
+ alias Pleroma.Web.Federator.RetryQueue
alias Pleroma.Web.OStatus
+
require Logger
@websub Application.get_env(:pleroma, :websub)
def start_link do
spawn(fn ->
# 1 minute
- Process.sleep(1000 * 60 * 1)
+ Process.sleep(1000 * 60)
enqueue(:refresh_subscriptions, nil)
end)
{:noreply, %{in: {i_running_jobs, i_queue}, out: {o_running_jobs, o_queue}}}
end
- def handle_cast(m, state) do
- IO.inspect("Unknown: #{inspect(m)}, #{inspect(state)}")
+ def handle_cast(_, state) do
{:noreply, state}
end
# https://tools.ietf.org/html/draft-cavage-http-signatures-08
defmodule Pleroma.Web.HTTPSignatures do
alias Pleroma.User
- alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Web.ActivityPub.ActivityPub
+ alias Pleroma.Web.ActivityPub.Utils
+
require Logger
def split_signature(sig) do
defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
use Pleroma.Web, :controller
- alias Pleroma.{Repo, Object, Activity, User, Notification, Stats}
+ alias Pleroma.Activity
+ alias Pleroma.Config
+ alias Pleroma.Filter
+ alias Pleroma.Notification
+ alias Pleroma.Object
+ alias Pleroma.Repo
+ alias Pleroma.Stats
+ alias Pleroma.User
alias Pleroma.Web
-
- alias Pleroma.Web.MastodonAPI.{
- StatusView,
- AccountView,
- MastodonView,
- ListView,
- FilterView,
- PushSubscriptionView
- }
-
- alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Web.CommonAPI
- alias Pleroma.Web.OAuth.{Authorization, Token, App}
alias Pleroma.Web.MediaProxy
+ alias Pleroma.Web.Push
+ alias Push.Subscription
+
+ alias Pleroma.Web.MastodonAPI.AccountView
+ alias Pleroma.Web.MastodonAPI.FilterView
+ alias Pleroma.Web.MastodonAPI.ListView
+ alias Pleroma.Web.MastodonAPI.MastodonView
+ alias Pleroma.Web.MastodonAPI.PushSubscriptionView
+ alias Pleroma.Web.MastodonAPI.StatusView
+ alias Pleroma.Web.ActivityPub.ActivityPub
+ alias Pleroma.Web.ActivityPub.Utils
+ alias Pleroma.Web.OAuth.App
+ alias Pleroma.Web.OAuth.Authorization
+ alias Pleroma.Web.OAuth.Token
import Ecto.Query
require Logger
@mastodon_api_level "2.5.0"
def masto_instance(conn, _params) do
- instance = Pleroma.Config.get(:instance)
+ instance = Config.get(:instance)
response = %{
uri: Web.base_url(),
|> Map.put("user", user)
activities =
- ActivityPub.fetch_activities([user.ap_id | user.following], params)
+ [user.ap_id | user.following]
+ |> ActivityPub.fetch_activities(params)
|> ActivityPub.contain_timeline(user)
|> Enum.reverse()
def public_timeline(%{assigns: %{user: user}} = conn, params) do
local_only = params["local"] in [true, "True", "true", "1"]
- params =
+ activities =
params
|> Map.put("type", ["Create", "Announce"])
|> Map.put("local_only", local_only)
|> Map.put("blocking_user", user)
-
- activities =
- ActivityPub.fetch_public_activities(params)
+ |> ActivityPub.fetch_public_activities()
|> Enum.reverse()
conn
as: :activity
)
|> Enum.reverse(),
+ # credo:disable-for-previous-line Credo.Check.Refactor.PipeChainStart
descendants:
StatusView.render(
"index.json",
as: :activity
)
|> Enum.reverse()
+ # credo:disable-for-previous-line Credo.Check.Refactor.PipeChainStart
}
json(conn, result)
notifications = Notification.for_user(user, params)
result =
- Enum.map(notifications, fn x ->
- render_notification(user, x)
- end)
+ notifications
+ |> Enum.map(fn x -> render_notification(user, x) end)
|> Enum.filter(& &1)
conn
[]
|> Enum.map(&String.downcase(&1))
- query_params =
+ activities =
params
|> Map.put("type", "Create")
|> Map.put("local_only", local_only)
|> Map.put("tag", tags)
|> Map.put("tag_all", tag_all)
|> Map.put("tag_reject", tag_reject)
-
- activities =
- ActivityPub.fetch_public_activities(query_params)
+ |> ActivityPub.fetch_public_activities()
|> Enum.reverse()
conn
{:ok, _activity} <- ActivityPub.follow(follower, followed),
{:ok, follower, followed} <-
User.wait_and_refresh(
- Pleroma.Config.get([:activitypub, :follow_handshake_timeout]),
+ Config.get([:activitypub, :follow_handshake_timeout]),
follower,
followed
) do
tags_path = Web.base_url() <> "/tag/"
tags =
- String.split(query)
+ query
+ |> String.split()
|> Enum.uniq()
|> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
|> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
statuses = status_search(user, query)
tags =
- String.split(query)
+ query
+ |> String.split()
|> Enum.uniq()
|> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
|> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
end
def favourites(%{assigns: %{user: user}} = conn, params) do
- params =
+ activities =
params
|> Map.put("type", "Create")
|> Map.put("favorited_by", user.ap_id)
|> Map.put("blocking_user", user)
-
- activities =
- ActivityPub.fetch_public_activities(params)
+ |> ActivityPub.fetch_public_activities()
|> Enum.reverse()
conn
# we must filter the following list for the user to avoid leaking statuses the user
# does not actually have permission to see (for more info, peruse security issue #270).
- following_to =
+ activities =
following
|> Enum.filter(fn x -> x in user.following end)
-
- activities =
- ActivityPub.fetch_activities_bounded(following_to, following, params)
+ |> ActivityPub.fetch_activities_bounded(following, params)
|> Enum.reverse()
conn
if user && token do
mastodon_emoji = mastodonized_emoji()
- limit = Pleroma.Config.get([:instance, :limit])
+ limit = Config.get([:instance, :limit])
accounts =
Map.put(%{}, user.id, AccountView.render("account.json", %{user: user, for: user}))
max_toot_chars: limit
},
rights: %{
- delete_others_notice: !!user.info.is_moderator,
- admin: !!user.info.is_admin
+ delete_others_notice: present?(user.info.is_moderator),
+ admin: present?(user.info.is_admin)
},
compose: %{
me: "#{user.id}",
end
def get_filters(%{assigns: %{user: user}} = conn, _) do
- filters = Pleroma.Filter.get_filters(user)
+ filters = Filter.get_filters(user)
res = FilterView.render("filters.json", filters: filters)
json(conn, res)
end
%{assigns: %{user: user}} = conn,
%{"phrase" => phrase, "context" => context} = params
) do
- query = %Pleroma.Filter{
+ query = %Filter{
user_id: user.id,
phrase: phrase,
context: context,
# expires_at
}
- {:ok, response} = Pleroma.Filter.create(query)
+ {:ok, response} = Filter.create(query)
res = FilterView.render("filter.json", filter: response)
json(conn, res)
end
def get_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
- filter = Pleroma.Filter.get(filter_id, user)
+ filter = Filter.get(filter_id, user)
res = FilterView.render("filter.json", filter: filter)
json(conn, res)
end
%{assigns: %{user: user}} = conn,
%{"phrase" => phrase, "context" => context, "id" => filter_id} = params
) do
- query = %Pleroma.Filter{
+ query = %Filter{
user_id: user.id,
filter_id: filter_id,
phrase: phrase,
# expires_at
}
- {:ok, response} = Pleroma.Filter.update(query)
+ {:ok, response} = Filter.update(query)
res = FilterView.render("filter.json", filter: response)
json(conn, res)
end
def delete_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
- query = %Pleroma.Filter{
+ query = %Filter{
user_id: user.id,
filter_id: filter_id
}
- {:ok, _} = Pleroma.Filter.delete(query)
+ {:ok, _} = Filter.delete(query)
json(conn, %{})
end
def create_push_subscription(%{assigns: %{user: user, token: token}} = conn, params) do
- true = Pleroma.Web.Push.enabled()
- Pleroma.Web.Push.Subscription.delete_if_exists(user, token)
- {:ok, subscription} = Pleroma.Web.Push.Subscription.create(user, token, params)
+ true = Push.enabled()
+ Subscription.delete_if_exists(user, token)
+ {:ok, subscription} = Subscription.create(user, token, params)
view = PushSubscriptionView.render("push_subscription.json", subscription: subscription)
json(conn, view)
end
def get_push_subscription(%{assigns: %{user: user, token: token}} = conn, _params) do
- true = Pleroma.Web.Push.enabled()
- subscription = Pleroma.Web.Push.Subscription.get(user, token)
+ true = Push.enabled()
+ subscription = Subscription.get(user, token)
view = PushSubscriptionView.render("push_subscription.json", subscription: subscription)
json(conn, view)
end
%{assigns: %{user: user, token: token}} = conn,
params
) do
- true = Pleroma.Web.Push.enabled()
- {:ok, subscription} = Pleroma.Web.Push.Subscription.update(user, token, params)
+ true = Push.enabled()
+ {:ok, subscription} = Subscription.update(user, token, params)
view = PushSubscriptionView.render("push_subscription.json", subscription: subscription)
json(conn, view)
end
def delete_push_subscription(%{assigns: %{user: user, token: token}} = conn, _params) do
- true = Pleroma.Web.Push.enabled()
- {:ok, _response} = Pleroma.Web.Push.Subscription.delete(user, token)
+ true = Push.enabled()
+ {:ok, _response} = Subscription.delete(user, token)
json(conn, %{})
end
end
def suggestions(%{assigns: %{user: user}} = conn, _) do
- suggestions = Pleroma.Config.get(:suggestions)
+ suggestions = Config.get(:suggestions)
if Keyword.get(suggestions, :enabled, false) do
api = Keyword.get(suggestions, :third_party_engine, "")
timeout = Keyword.get(suggestions, :timeout, 5000)
limit = Keyword.get(suggestions, :limit, 23)
- host = Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host])
+ host = Config.get([Pleroma.Web.Endpoint, :url, :host])
user = user.nickname
- url = String.replace(api, "{{host}}", host) |> String.replace("{{user}}", user)
+
+ url =
+ api
+ |> String.replace("{{host}}", host)
+ |> String.replace("{{user}}", user)
with {:ok, %{status: 200, body: body}} <-
@httpoison.get(
]
),
{:ok, data} <- Jason.decode(body) do
- data2 =
- Enum.slice(data, 0, limit)
+ data =
+ data
+ |> Enum.slice(0, limit)
|> Enum.map(fn x ->
Map.put(
x,
end)
conn
- |> json(data2)
+ |> json(data)
else
e -> Logger.error("Could not retrieve suggestions at fetch #{url}, #{inspect(e)}")
end
|> put_status(501)
|> json(%{error: "Can't display this activity"})
end
+
+ defp present?(nil), do: false
+ defp present?(false), do: false
+ defp present?(_), do: true
end
defmodule Pleroma.Web.MastodonAPI.AccountView do
use Pleroma.Web, :view
+
+ alias Pleroma.HTML
alias Pleroma.User
- alias Pleroma.Web.MastodonAPI.AccountView
alias Pleroma.Web.CommonAPI.Utils
+ alias Pleroma.Web.MastodonAPI.AccountView
alias Pleroma.Web.MediaProxy
- alias Pleroma.HTML
def render("accounts.json", %{users: users} = opts) do
users
defmodule Pleroma.Web.MastodonAPI.FilterView do
use Pleroma.Web, :view
- alias Pleroma.Web.MastodonAPI.FilterView
alias Pleroma.Web.CommonAPI.Utils
+ alias Pleroma.Web.MastodonAPI.FilterView
def render("filters.json", %{filters: filters} = opts) do
render_many(filters, FilterView, "filter.json", opts)
alias Pleroma.Repo
alias Pleroma.User
alias Pleroma.Web.CommonAPI.Utils
- alias Pleroma.Web.MediaProxy
alias Pleroma.Web.MastodonAPI.AccountView
alias Pleroma.Web.MastodonAPI.StatusView
+ alias Pleroma.Web.MediaProxy
# TODO: Add cached version.
defp get_replied_to_activities(activities) do
require Logger
alias Pleroma.Web.OAuth.Token
- alias Pleroma.{User, Repo}
+ alias Pleroma.Repo
+ alias Pleroma.User
@behaviour :cowboy_websocket_handler
defmodule Pleroma.Web.MediaProxy.MediaProxyController do
use Pleroma.Web, :controller
- alias Pleroma.{Web.MediaProxy, ReverseProxy}
+ alias Pleroma.ReverseProxy
+ alias Pleroma.Web.MediaProxy
@default_proxy_opts [max_body_length: 25 * 1_048_576, http: [follow_redirect: true]]
- def remote(conn, params = %{"sig" => sig64, "url" => url64}) do
+ def remote(conn, %{"sig" => sig64, "url" => url64} = params) do
with config <- Pleroma.Config.get([:media_proxy], []),
true <- Keyword.get(config, :enabled, false),
{:ok, url} <- MediaProxy.decode_url(sig64, url64),
def url(""), do: nil
- def url(url = "/" <> _), do: url
+ def url("/" <> _ = url), do: url
def url(url) do
config = Application.get_env(:pleroma, :media_proxy, [])
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.Metadata.Providers.OpenGraph do
- alias Pleroma.Web.Metadata.Providers.Provider
+ alias Pleroma.HTML
+ alias Pleroma.Formatter
+ alias Pleroma.User
alias Pleroma.Web.Metadata
- alias Pleroma.{HTML, Formatter, User}
alias Pleroma.Web.MediaProxy
+ alias Pleroma.Web.Metadata.Providers.Provider
@behaviour Provider
defmodule Pleroma.Web.Nodeinfo.NodeinfoController do
use Pleroma.Web, :controller
+ alias Pleroma.Config
+ alias Pleroma.Repo
alias Pleroma.Stats
+ alias Pleroma.User
alias Pleroma.Web
- alias Pleroma.{User, Repo}
- alias Pleroma.Config
alias Pleroma.Web.ActivityPub.MRF
plug(Pleroma.Web.FederatingPlug)
# returns a nodeinfo 2.0 map, since 2.1 just adds a repository field
# under software.
- def raw_nodeinfo() do
+ def raw_nodeinfo do
instance = Application.get_env(:pleroma, :instance)
media_proxy = Application.get_env(:pleroma, :media_proxy)
suggestions = Application.get_env(:pleroma, :suggestions)
Config.get([:mrf_user_allowlist], [])
|> Enum.into(%{}, fn {k, v} -> {k, length(v)} end)
- mrf_transparency = Keyword.get(instance, :mrf_transparency)
-
federation_response =
- if mrf_transparency do
+ if Keyword.get(instance, :mrf_transparency) do
%{
mrf_policies: mrf_policies,
mrf_simple: mrf_simple,
defmodule Pleroma.Web.OAuth.App do
use Ecto.Schema
- import Ecto.{Changeset}
+ import Ecto.Changeset
schema "apps" do
field(:client_name, :string)
defmodule Pleroma.Web.OAuth.Authorization do
use Ecto.Schema
- alias Pleroma.{User, Repo}
- alias Pleroma.Web.OAuth.{Authorization, App}
+ alias Pleroma.User
+ alias Pleroma.Repo
+ alias Pleroma.Web.OAuth.Authorization
+ alias Pleroma.Web.OAuth.App
- import Ecto.{Changeset, Query}
+ import Ecto.Changeset
+ import Ecto.Query
schema "oauth_authorizations" do
field(:token, :string)
defmodule Pleroma.Web.OAuth.OAuthController do
use Pleroma.Web, :controller
- alias Pleroma.Web.OAuth.{Authorization, Token, App}
- alias Pleroma.{Repo, User}
+ alias Pleroma.Web.OAuth.Authorization
+ alias Pleroma.Web.OAuth.Token
+ alias Pleroma.Web.OAuth.App
+ alias Pleroma.Repo
+ alias Pleroma.User
alias Comeonin.Pbkdf2
plug(:fetch_session)
import Ecto.Query
- alias Pleroma.{User, Repo}
- alias Pleroma.Web.OAuth.{Token, App, Authorization}
+ alias Pleroma.User
+ alias Pleroma.Repo
+ alias Pleroma.Web.OAuth.Token
+ alias Pleroma.Web.OAuth.App
+ alias Pleroma.Web.OAuth.Authorization
schema "oauth_tokens" do
field(:token, :string)
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.OStatus.ActivityRepresenter do
- alias Pleroma.{Activity, User, Object}
+ alias Pleroma.Activity
+ alias Pleroma.User
+ alias Pleroma.Object
alias Pleroma.Web.OStatus.UserRepresenter
+
require Logger
defp get_href(id) do
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.OStatus.FeedRepresenter do
- alias Pleroma.Web.OStatus
- alias Pleroma.Web.OStatus.{UserRepresenter, ActivityRepresenter}
alias Pleroma.User
+ alias Pleroma.Web.OStatus
alias Pleroma.Web.MediaProxy
+ alias Pleroma.Web.OStatus.ActivityRepresenter
+ alias Pleroma.Web.OStatus.UserRepresenter
def to_simple_form(user, activities, _users) do
most_recent_update =
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.OStatus.FollowHandler do
- alias Pleroma.Web.{XML, OStatus}
+ alias Pleroma.Web.XML
+ alias Pleroma.Web.OStatus
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.User
defmodule Pleroma.Web.OStatus.NoteHandler do
require Logger
- alias Pleroma.Web.{XML, OStatus}
- alias Pleroma.{Object, Activity}
+ alias Pleroma.Web.OStatus
+ alias Pleroma.Web.XML
+ alias Pleroma.Activity
+ alias Pleroma.Object
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.ActivityPub.Utils
alias Pleroma.Web.CommonAPI
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.OStatus.UnfollowHandler do
- alias Pleroma.Web.{XML, OStatus}
+ alias Pleroma.Web.XML
+ alias Pleroma.Web.OStatus
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.User
import Pleroma.Web.XML
require Logger
- alias Pleroma.{Repo, User, Web, Object, Activity}
+ alias Pleroma.Repo
+ alias Pleroma.User
+ alias Pleroma.Web
+ alias Pleroma.Object
+ alias Pleroma.Activity
alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.Web.{WebFinger, Websub}
- alias Pleroma.Web.OStatus.{FollowHandler, UnfollowHandler, NoteHandler, DeleteHandler}
alias Pleroma.Web.ActivityPub.Transmogrifier
+ alias Pleroma.Web.WebFinger
+ alias Pleroma.Web.Websub
+ alias Pleroma.Web.OStatus.FollowHandler
+ alias Pleroma.Web.OStatus.UnfollowHandler
+ alias Pleroma.Web.OStatus.NoteHandler
+ alias Pleroma.Web.OStatus.DeleteHandler
def is_representable?(%Activity{data: data}) do
object = Object.normalize(data["object"])
defmodule Pleroma.Web.OStatus.OStatusController do
use Pleroma.Web, :controller
- alias Pleroma.{User, Activity, Object}
- alias Pleroma.Web.OStatus.{FeedRepresenter, ActivityRepresenter}
- alias Pleroma.Web.{OStatus, Federator}
- alias Pleroma.Web.XML
- alias Pleroma.Web.ActivityPub.ObjectView
- alias Pleroma.Web.ActivityPub.ActivityPubController
+ alias Pleroma.Activity
+ alias Pleroma.Object
+ alias Pleroma.User
alias Pleroma.Web.ActivityPub.ActivityPub
+ alias Pleroma.Web.ActivityPub.ActivityPubController
+ alias Pleroma.Web.ActivityPub.ObjectView
+ alias Pleroma.Web.OStatus.ActivityRepresenter
+ alias Pleroma.Web.OStatus.FeedRepresenter
+ alias Pleroma.Web.Federator
+ alias Pleroma.Web.OStatus
+ alias Pleroma.Web.XML
plug(Pleroma.Web.FederatingPlug when action in [:salmon_incoming])
defmodule Pleroma.Web.Push do
use GenServer
- alias Pleroma.{Repo, User}
+ alias Pleroma.Repo
+ alias Pleroma.User
alias Pleroma.Web.Push.Subscription
require Logger
defmodule Pleroma.Web.Push.Subscription do
use Ecto.Schema
+
import Ecto.Changeset
- alias Pleroma.{Repo, User}
+
+ alias Pleroma.Repo
+ alias Pleroma.User
alias Pleroma.Web.OAuth.Token
alias Pleroma.Web.Push.Subscription
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.RichMedia.Helpers do
- alias Pleroma.{Activity, Object, HTML}
+ alias Pleroma.Activity
+ alias Pleroma.Object
+ alias Pleroma.HTML
alias Pleroma.Web.RichMedia.Parser
def fetch_data_for_activity(%Activity{} = activity) do
@httpoison Application.get_env(:pleroma, :httpoison)
use Bitwise
+
alias Pleroma.Instances
+ alias Pleroma.User
alias Pleroma.Web.XML
alias Pleroma.Web.OStatus.ActivityRepresenter
- alias Pleroma.User
+
require Logger
def decode(salmon) do
defmodule Pleroma.Web.Streamer do
use GenServer
require Logger
- alias Pleroma.{User, Notification, Activity, Object, Repo}
+ alias Pleroma.User
+ alias Pleroma.Notification
+ alias Pleroma.Activity
+ alias Pleroma.Object
+ alias Pleroma.Repo
alias Pleroma.Web.ActivityPub.ActivityPub
@keepalive_interval :timer.seconds(30)
defmodule Pleroma.Web.TwitterAPI.UtilController do
use Pleroma.Web, :controller
+
require Logger
+
+ alias Comeonin.Pbkdf2
+ alias Pleroma.Emoji
+ alias Pleroma.PasswordResetToken
+ alias Pleroma.User
+ alias Pleroma.Repo
alias Pleroma.Web
+ alias Pleroma.Web.CommonAPI
alias Pleroma.Web.OStatus
alias Pleroma.Web.WebFinger
- alias Pleroma.Web.CommonAPI
- alias Comeonin.Pbkdf2
alias Pleroma.Web.ActivityPub.ActivityPub
- alias Pleroma.{Repo, PasswordResetToken, User, Emoji}
def show_password_reset(conn, %{"token" => token}) do
with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}),
# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
+# FIXME: Remove this module?
# THIS MODULE IS DEPRECATED! DON'T USE IT!
# USE THE Pleroma.Web.TwitterAPI.Views.ActivityView MODULE!
defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter do
use Pleroma.Web.TwitterAPI.Representers.BaseRepresenter
alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
- alias Pleroma.{Activity, User}
- alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView, ActivityView}
- alias Pleroma.Web.CommonAPI.Utils
+ alias Pleroma.Activity
alias Pleroma.Formatter
alias Pleroma.HTML
+ alias Pleroma.User
+ alias Pleroma.Web.TwitterAPI.ActivityView
+ alias Pleroma.Web.TwitterAPI.TwitterAPI
+ alias Pleroma.Web.TwitterAPI.UserView
+ alias Pleroma.Web.CommonAPI.Utils
alias Pleroma.Web.MastodonAPI.StatusView
defp user_by_ap_id(user_list, ap_id) do
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
- alias Pleroma.{UserInviteToken, User, Activity, Repo, Object}
- alias Pleroma.{UserEmail, Mailer}
+ alias Pleroma.UserInviteToken
+ alias Pleroma.User
+ alias Pleroma.Activity
+ alias Pleroma.Repo
+ alias Pleroma.Object
+ alias Pleroma.UserEmail
+ alias Pleroma.Mailer
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.TwitterAPI.UserView
alias Pleroma.Web.CommonAPI
import Pleroma.Web.ControllerHelper, only: [json_response: 3]
- alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView, ActivityView, NotificationView}
- alias Pleroma.Web.CommonAPI
- alias Pleroma.{Repo, Activity, Object, User, Notification}
+ alias Ecto.Changeset
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.ActivityPub.Utils
- alias Ecto.Changeset
+ alias Pleroma.Web.CommonAPI
+ alias Pleroma.Web.TwitterAPI.ActivityView
+ alias Pleroma.Web.TwitterAPI.NotificationView
+ alias Pleroma.Web.TwitterAPI.TwitterAPI
+ alias Pleroma.Web.TwitterAPI.UserView
+ alias Pleroma.Activity
+ alias Pleroma.Object
+ alias Pleroma.Notification
+ alias Pleroma.Repo
+ alias Pleroma.User
require Logger
defmodule Pleroma.Web.TwitterAPI.ActivityView do
use Pleroma.Web, :view
- alias Pleroma.Web.CommonAPI.Utils
- alias Pleroma.User
- alias Pleroma.Web.TwitterAPI.UserView
- alias Pleroma.Web.TwitterAPI.ActivityView
- alias Pleroma.Web.TwitterAPI.TwitterAPI
- alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
- alias Pleroma.Web.MastodonAPI.StatusView
alias Pleroma.Activity
+ alias Pleroma.Formatter
alias Pleroma.HTML
alias Pleroma.Object
- alias Pleroma.User
alias Pleroma.Repo
- alias Pleroma.Formatter
+ alias Pleroma.User
+ alias Pleroma.Web.CommonAPI.Utils
+ alias Pleroma.Web.MastodonAPI.StatusView
+ alias Pleroma.Web.TwitterAPI.ActivityView
+ alias Pleroma.Web.TwitterAPI.TwitterAPI
+ alias Pleroma.Web.TwitterAPI.UserView
+ alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
import Ecto.Query
require Logger
defmodule Pleroma.Web.TwitterAPI.NotificationView do
use Pleroma.Web, :view
- alias Pleroma.{Notification, User}
+ alias Pleroma.Notification
+ alias Pleroma.User
alias Pleroma.Web.CommonAPI.Utils
- alias Pleroma.Web.TwitterAPI.UserView
alias Pleroma.Web.TwitterAPI.ActivityView
+ alias Pleroma.Web.TwitterAPI.UserView
defp get_user(ap_id, opts) do
cond do
defmodule Pleroma.Web.TwitterAPI.UserView do
use Pleroma.Web, :view
- alias Pleroma.User
alias Pleroma.Formatter
+ alias Pleroma.HTML
+ alias Pleroma.User
alias Pleroma.Web.CommonAPI.Utils
alias Pleroma.Web.MediaProxy
- alias Pleroma.HTML
def render("show.json", %{user: user = %User{}} = assigns) do
render_one(user, Pleroma.Web.TwitterAPI.UserView, "user.json", assigns)
alias Pleroma.Uploaders.Uploader
- def callback(conn, params = %{"upload_path" => upload_path}) do
+ def callback(conn, %{"upload_path" => upload_path} = params) do
process_callback(conn, :global.whereis_name({Uploader, upload_path}), params)
end
quote do
use Phoenix.Controller, namespace: Pleroma.Web
import Plug.Conn
- import Pleroma.Web.{Gettext, Router.Helpers}
+ import Pleroma.Web.Gettext
+ import Pleroma.Web.Router.Helpers
end
end
# Import convenience functions from controllers
import Phoenix.Controller, only: [get_csrf_token: 0, get_flash: 2, view_module: 1]
- import Pleroma.Web.{ErrorHelpers, Gettext, Router.Helpers}
+ import Pleroma.Web.ErrorHelpers
+ import Pleroma.Web.Gettext
+ import Pleroma.Web.Router.Helpers
require Logger
def router do
quote do
use Phoenix.Router
+ # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
import Plug.Conn
import Phoenix.Controller
end
def channel do
quote do
+ # credo:disable-for-next-line Credo.Check.Consistency.MultiAliasImportRequireUse
use Phoenix.Channel
import Pleroma.Web.Gettext
end
defmodule Pleroma.Web.WebFinger do
@httpoison Application.get_env(:pleroma, :httpoison)
- alias Pleroma.{User, XmlBuilder}
+ alias Pleroma.User
+ alias Pleroma.XmlBuilder
alias Pleroma.Web
- alias Pleroma.Web.{XML, Salmon, OStatus}
+ alias Pleroma.Web.XML
+ alias Pleroma.Web.Salmon
+ alias Pleroma.Web.OStatus
require Jason
require Logger
defmodule Pleroma.Web.Websub do
alias Ecto.Changeset
- alias Pleroma.Repo
alias Pleroma.Instances
- alias Pleroma.Web.Websub.{WebsubServerSubscription, WebsubClientSubscription}
+ alias Pleroma.Repo
+ alias Pleroma.Web.Websub.WebsubServerSubscription
+ alias Pleroma.Web.Websub.WebsubClientSubscription
alias Pleroma.Web.OStatus.FeedRepresenter
- alias Pleroma.Web.{XML, Endpoint, OStatus}
+ alias Pleroma.Web.XML
+ alias Pleroma.Web.Endpoint
+ alias Pleroma.Web.OStatus
alias Pleroma.Web.Router.Helpers
require Logger
defmodule Pleroma.Web.Websub.WebsubController do
use Pleroma.Web, :controller
- alias Pleroma.{Repo, User}
- alias Pleroma.Web.{Websub, Federator}
+ alias Pleroma.Repo
+ alias Pleroma.User
+ alias Pleroma.Web.Websub
+ alias Pleroma.Web.Federator
alias Pleroma.Web.Websub.WebsubClientSubscription
require Logger