config :mime, :types, %{
"application/xml" => ["xml"],
"application/xrd+xml" => ["xrd+xml"],
+ "application/jrd+json" => ["jrd+json"],
"application/activity+json" => ["activity+json"],
"application/ld+json" => ["activity+json"]
}
* `avatar_upload_limit`: File size limit of user’s profile avatars
* `background_upload_limit`: File size limit of user’s profile backgrounds
* `banner_upload_limit`: File size limit of user’s profile banners
-* `registrations_open`: Enable registrations for anyone, invitations can be used when false.
+* `registrations_open`: Enable registrations for anyone, invitations can be enabled when false.
+* `invites_enabled`: Enable user invitations for admins (depends on `registrations_open: false`).
* `federating`: Enable federation with other instances
* `allow_relay`: Enable Pleroma’s Relay, which makes it possible to follow a whole instance
* `rewrite_policy`: Message Rewrite Policy, either one or a list. Here are the ones available by default:
protocol_options: [max_request_line_length: 8192, max_header_value_length: 8192]
],
protocol: "http",
+ secure_cookie_flag: false,
debug_errors: true,
code_reloader: true,
check_origin: false,
proceed? = Enum.empty?(will_overwrite) or Keyword.get(options, :force, false)
unless not proceed? do
- domain =
- Common.get_option(
- options,
- :domain,
- "What domain will your instance use? (e.g pleroma.soykaf.com)"
- )
+ [domain, port | _] =
+ String.split(
+ Common.get_option(
+ options,
+ :domain,
+ "What domain will your instance use? (e.g pleroma.soykaf.com)"
+ ),
+ ":"
+ ) ++ [443]
name =
Common.get_option(
EEx.eval_file(
"sample_config.eex" |> Path.expand(__DIR__),
domain: domain,
+ port: port,
email: email,
name: name,
dbhost: dbhost,
use Mix.Config
config :pleroma, Pleroma.Web.Endpoint,
- url: [host: "<%= domain %>", scheme: "https", port: 443],
+ url: [host: "<%= domain %>", scheme: "https", port: <%= port %>],
secret_key_base: "<%= secret %>"
config :pleroma, :instance,
|> subject("Password reset")
|> html_body(html_body)
end
+
+ def user_invitation_email(
+ user,
+ %Pleroma.UserInviteToken{} = user_invite_token,
+ to_email,
+ to_name \\ nil
+ ) do
+ registration_url =
+ Router.Helpers.redirect_url(
+ Endpoint,
+ :registration_page,
+ user_invite_token.token
+ )
+
+ html_body = """
+ <h3>You are invited to #{instance_name()}</h3>
+ <p>#{user.name} invites you to join #{instance_name()}, an instance of Pleroma federated social networking platform.</p>
+ <p>Click the following link to register: <a href="#{registration_url}">accept invitation</a>.</p>
+ """
+
+ new()
+ |> to(recipient(to_email, to_name))
+ |> from(sender())
+ |> subject("Invitation to #{instance_name()}")
+ |> html_body(html_body)
+ end
end
alias Pleroma.Emoji
@tag_regex ~r/\#\w+/u
+ @markdown_characters_regex ~r/(`|\*|_|{|}|[|]|\(|\)|#|\+|-|\.|!)/
+
def parse_tags(text, data \\ %{}) do
Regex.scan(@tag_regex, text)
|> Enum.map(fn ["#" <> tag = full_tag] -> {full_tag, String.downcase(tag)} end)
|> Enum.join("")
end
+ @doc """
+ Escapes a special characters in mention names.
+ """
+ @spec mentions_escape(String.t(), list({String.t(), any()})) :: String.t()
+ def mentions_escape(text, mentions) do
+ mentions
+ |> Enum.reduce(text, fn {name, _}, acc ->
+ escape_name = String.replace(name, @markdown_characters_regex, "\\\\\\1")
+ String.replace(acc, name, escape_name)
+ end)
+ end
+
@doc "changes scheme:... urls to html links"
def add_links({subs, text}) do
links =
end)
end
- def filter_tags(html, scrubber) do
- html |> Scrubber.scrub(scrubber)
- end
-
+ def filter_tags(html, scrubber), do: Scrubber.scrub(html, scrubber)
def filter_tags(html), do: filter_tags(html, nil)
-
- def strip_tags(html) do
- html |> Scrubber.scrub(Scrubber.StripTags)
- end
+ def strip_tags(html), do: Scrubber.scrub(html, Scrubber.StripTags)
end
defmodule Pleroma.HTML.Scrubber.TwitterText do
])
end
- def mastodon_settings_update(info, params) do
+ def mastodon_settings_update(info, settings) do
+ params = %{settings: settings}
+
info
|> cast(params, [:settings])
+ |> validate_required([:settings])
end
def set_source_data(info, source_data) do
end
end
+ @doc "Sends registration invite via email"
+ def email_invite(%{assigns: %{user: user}} = conn, %{"email" => email} = params) do
+ with true <-
+ Pleroma.Config.get([:instance, :invites_enabled]) &&
+ !Pleroma.Config.get([:instance, :registrations_open]),
+ {:ok, invite_token} <- Pleroma.UserInviteToken.create_token(),
+ email <-
+ Pleroma.UserEmail.user_invitation_email(user, invite_token, email, params["name"]),
+ {:ok, _} <- Pleroma.Mailer.deliver(email) do
+ json_response(conn, :no_content, "")
+ end
+ end
+
@doc "Get a account registeration invite token (base64 string)"
def get_invite_token(conn, _params) do
{:ok, token} = Pleroma.UserInviteToken.create_token()
Enum.join([text | attachment_text], "<br>")
end
+ @doc """
+ Formatting text to plain text.
+ """
def format_input(text, mentions, tags, "text/plain") do
text
|> Formatter.html_escape("text/plain")
|> Formatter.finalize()
end
+ @doc """
+ Formatting text to html.
+ """
def format_input(text, mentions, _tags, "text/html") do
text
|> Formatter.html_escape("text/html")
|> Formatter.finalize()
end
+ @doc """
+ Formatting text to markdown.
+ """
def format_input(text, mentions, tags, "text/markdown") do
text
+ |> Formatter.mentions_escape(mentions)
|> Earmark.as_html!()
|> Formatter.html_escape("text/html")
|> String.replace(~r/\r?\n/, "")
]
},
settings:
- Map.get(user.info, :settings) ||
+ user.info.settings ||
%{
onboarded: true,
home: %{
def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
info_cng = User.Info.mastodon_settings_update(user.info, settings)
- with changeset <- User.update_changeset(user),
+ with changeset <- Ecto.Changeset.change(user),
changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
{:ok, _user} <- User.update_and_set_cache(changeset) do
json(conn, %{})
else
e ->
- json(conn, %{error: inspect(e)})
+ conn
+ |> put_resp_content_type("application/json")
+ |> send_resp(500, Jason.encode!(%{"error" => inspect(e)}))
end
end
visibility: get_visibility(object),
media_attachments: attachments |> Enum.take(4),
mentions: mentions,
- tags: tags,
+ tags: build_tags(tags),
application: %{
name: "Web",
website: nil
def render_content(object), do: object["content"] || ""
+ @doc """
+ Builds a dictionary tags.
+
+ ## Examples
+
+ iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
+ [{"name": "fediverse", "url": "/tag/fediverse"},
+ {"name": "nextcloud", "url": "/tag/nextcloud"}]
+
+ """
+ @spec build_tags(list(any())) :: list(map())
+ def build_tags(object_tags) when is_list(object_tags) do
+ object_tags = for tag when is_binary(tag) <- object_tags, do: tag
+
+ Enum.reduce(object_tags, [], fn tag, tags ->
+ tags ++ [%{name: tag, url: "/tag/#{tag}"}]
+ end)
+ end
+
+ def build_tags(_), do: []
+
@doc """
Builds list emojis.
banner: Keyword.get(instance, :banner_upload_limit),
background: Keyword.get(instance, :background_upload_limit)
},
+ invitesEnabled: Keyword.get(instance, :invites_enabled, false),
features: features
}
}
delete("/relay", AdminAPIController, :relay_unfollow)
get("/invite_token", AdminAPIController, :get_invite_token)
+ post("/email_invite", AdminAPIController, :email_invite)
+
get("/password_reset", AdminAPIController, :get_password_reset)
end
uploadlimit: uploadlimit,
closed: if(Keyword.get(instance, :registrations_open), do: "0", else: "1"),
private: if(Keyword.get(instance, :public, true), do: "0", else: "1"),
- vapidPublicKey: vapid_public_key
+ vapidPublicKey: vapid_public_key,
+ invitesEnabled: if(Keyword.get(instance, :invites_enabled, false), do: "1", else: "0")
}
pleroma_fe = %{
alias Pleroma.HTML
import Ecto.Query
+ require Logger
defp query_context_ids([]), do: []
{summary, content} = render_content(object)
html =
- HTML.filter_tags(content, User.html_filter_policy(opts[:for]))
+ content
+ |> HTML.filter_tags(User.html_filter_policy(opts[:for]))
|> Formatter.emojify(object["emoji"])
reply_parent = Activity.get_in_reply_to_activity(activity)
}
end
+ def render("activity.json", %{activity: unhandled_activity}) do
+ Logger.warn("#{__MODULE__} unhandled activity: #{inspect(unhandled_activity)}")
+ nil
+ end
+
def render_content(%{"type" => "Note"} = object) do
summary = object["summary"]
elixir: "~> 1.4",
elixirc_paths: elixirc_paths(Mix.env()),
compilers: [:phoenix, :gettext] ++ Mix.compilers(),
- elixirc_options:
- if Mix.env() == :test do
- []
- else
- [warnings_as_errors: true]
- end,
+ elixirc_options: [warnings_as_errors: true],
start_permanent: Mix.env() == :prod,
aliases: aliases(),
deps: deps(),
{:mogrify, "~> 0.6.1"},
{:ex_aws, "~> 2.0"},
{:ex_aws_s3, "~> 2.0"},
- {:earmark, "~> 1.2"},
+ {:earmark, "~> 1.3"},
{:ex_machina, "~> 2.2", only: :test},
{:credo, "~> 0.9.3", only: [:dev, :test]},
{:mock, "~> 0.3.1", only: :test},
"crypt": {:git, "https://github.com/msantos/crypt", "1f2b58927ab57e72910191a7ebaeff984382a1d3", [ref: "1f2b58927ab57e72910191a7ebaeff984382a1d3"]},
"db_connection": {:hex, :db_connection, "1.1.3", "89b30ca1ef0a3b469b1c779579590688561d586694a3ce8792985d4d7e575a61", [:mix], [{:connection, "~> 1.0.2", [hex: :connection, repo: "hexpm", optional: false]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, repo: "hexpm", optional: true]}], "hexpm"},
"decimal": {:hex, :decimal, "1.5.0", "b0433a36d0e2430e3d50291b1c65f53c37d56f83665b43d79963684865beab68", [:mix], [], "hexpm"},
- "earmark": {:hex, :earmark, "1.2.6", "b6da42b3831458d3ecc57314dff3051b080b9b2be88c2e5aa41cd642a5b044ed", [:mix], [], "hexpm"},
+ "earmark": {:hex, :earmark, "1.3.0", "17f0c38eaafb4800f746b457313af4b2442a8c2405b49c645768680f900be603", [:mix], [], "hexpm"},
"ecto": {:hex, :ecto, "2.2.10", "e7366dc82f48f8dd78fcbf3ab50985ceeb11cb3dc93435147c6e13f2cda0992e", [:mix], [{:db_connection, "~> 1.1", [hex: :db_connection, repo: "hexpm", optional: true]}, {:decimal, "~> 1.2", [hex: :decimal, repo: "hexpm", optional: false]}, {:mariaex, "~> 0.8.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:poison, "~> 2.2 or ~> 3.0", [hex: :poison, repo: "hexpm", optional: true]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.13.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:sbroker, "~> 1.0", [hex: :sbroker, repo: "hexpm", optional: true]}], "hexpm"},
"eternal": {:hex, :eternal, "1.2.0", "e2a6b6ce3b8c248f7dc31451aefca57e3bdf0e48d73ae5043229380a67614c41", [:mix], [], "hexpm"},
"ex_aws": {:hex, :ex_aws, "2.1.0", "b92651527d6c09c479f9013caa9c7331f19cba38a650590d82ebf2c6c16a1d8a", [:mix], [{:configparser_ex, "~> 2.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "1.6.3 or 1.6.5 or 1.7.1 or 1.8.6 or ~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jsx, "~> 2.8", [hex: :jsx, repo: "hexpm", optional: true]}, {:poison, ">= 1.2.0", [hex: :poison, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}, {:xml_builder, "~> 0.1.0", [hex: :xml_builder, repo: "hexpm", optional: true]}], "hexpm"},
text = nil
assert Formatter.get_emoji(text) == []
end
+
+ describe "/mentions_escape" do
+ test "it returns text with escaped mention names" do
+ text = """
+ @a_breakin_glass@cybre.space
+ (also, little voice inside my head thinking "maybe this will encourage people
+ pronouncing it properly instead of saying _raKEWdo_ ")
+ """
+
+ escape_text = """
+ @a\\_breakin\\_glass@cybre\\.space
+ (also, little voice inside my head thinking \"maybe this will encourage people
+ pronouncing it properly instead of saying _raKEWdo_ \")
+ """
+
+ mentions = [{"@a_breakin_glass@cybre.space", %{}}]
+ assert Formatter.mentions_escape(text, mentions) == escape_text
+ end
+ end
end
end
end
+ describe "POST /api/pleroma/admin/email_invite, with valid config" do
+ setup do
+ registrations_open = Pleroma.Config.get([:instance, :registrations_open])
+ invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
+ Pleroma.Config.put([:instance, :registrations_open], false)
+ Pleroma.Config.put([:instance, :invites_enabled], true)
+
+ on_exit(fn ->
+ Pleroma.Config.put([:instance, :registrations_open], registrations_open)
+ Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
+ :ok
+ end)
+
+ [user: insert(:user, info: %{is_admin: true})]
+ end
+
+ test "sends invitation and returns 204", %{conn: conn, user: user} do
+ recipient_email = "foo@bar.com"
+ recipient_name = "J. D."
+
+ conn =
+ conn
+ |> assign(:user, user)
+ |> post("/api/pleroma/admin/email_invite?email=#{recipient_email}&name=#{recipient_name}")
+
+ assert json_response(conn, :no_content)
+
+ token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
+ assert token_record
+ refute token_record.used
+
+ Swoosh.TestAssertions.assert_email_sent(
+ Pleroma.UserEmail.user_invitation_email(
+ user,
+ token_record,
+ recipient_email,
+ recipient_name
+ )
+ )
+ end
+
+ test "it returns 403 if requested by a non-admin", %{conn: conn} do
+ non_admin_user = insert(:user)
+
+ conn =
+ conn
+ |> assign(:user, non_admin_user)
+ |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
+
+ assert json_response(conn, :forbidden)
+ end
+ end
+
+ describe "POST /api/pleroma/admin/email_invite, with invalid config" do
+ setup do
+ [user: insert(:user, info: %{is_admin: true})]
+ end
+
+ test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
+ registrations_open = Pleroma.Config.get([:instance, :registrations_open])
+ invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
+ Pleroma.Config.put([:instance, :registrations_open], false)
+ Pleroma.Config.put([:instance, :invites_enabled], false)
+
+ on_exit(fn ->
+ Pleroma.Config.put([:instance, :registrations_open], registrations_open)
+ Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
+ :ok
+ end)
+
+ conn =
+ conn
+ |> assign(:user, user)
+ |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
+
+ assert json_response(conn, :internal_server_error)
+ end
+
+ test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
+ registrations_open = Pleroma.Config.get([:instance, :registrations_open])
+ invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
+ Pleroma.Config.put([:instance, :registrations_open], true)
+ Pleroma.Config.put([:instance, :invites_enabled], true)
+
+ on_exit(fn ->
+ Pleroma.Config.put([:instance, :registrations_open], registrations_open)
+ Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
+ :ok
+ end)
+
+ conn =
+ conn
+ |> assign(:user, user)
+ |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
+
+ assert json_response(conn, :internal_server_error)
+ end
+ end
+
test "/api/pleroma/admin/invite_token" do
admin = insert(:user, info: %{is_admin: true})
assert result["stats"]["user_count"] == 2
assert result["stats"]["status_count"] == 1
end
+
+ test "put settings", %{conn: conn} do
+ user = insert(:user)
+
+ conn =
+ conn
+ |> assign(:user, user)
+ |> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})
+
+ assert result = json_response(conn, 200)
+
+ user = User.get_cached_by_ap_id(user.ap_id)
+ assert user.info.settings == %{"programming" => "socks"}
+ end
end
visibility: "public",
media_attachments: [],
mentions: [],
- tags: note.data["object"]["tag"],
+ tags: [
+ %{
+ name: "#{note.data["object"]["tag"]}",
+ url: "/tag/#{note.data["object"]["tag"]}"
+ }
+ ],
application: %{
name: "Web",
website: nil
assert represented[:reblog][:id] == to_string(activity.id)
assert represented[:emojis] == []
end
+
+ describe "build_tags/1" do
+ test "it returns a a dictionary tags" do
+ object_tags = [
+ "fediverse",
+ "mastodon",
+ "nextcloud",
+ %{
+ "href" => "https://kawen.space/users/lain",
+ "name" => "@lain@kawen.space",
+ "type" => "Mention"
+ }
+ ]
+
+ assert StatusView.build_tags(object_tags) == [
+ %{name: "fediverse", url: "/tag/fediverse"},
+ %{name: "mastodon", url: "/tag/mastodon"},
+ %{name: "nextcloud", url: "/tag/nextcloud"}
+ ]
+ end
+ end
end
--- /dev/null
+defmodule Pleroma.Web.WebFinger.WebFingerControllerTest do
+ use Pleroma.Web.ConnCase
+
+ alias Pleroma.User
+ alias Pleroma.Web.WebFinger.WebFingerController
+
+ import Pleroma.Factory
+ import ExUnit.CaptureLog
+ import Tesla.Mock
+
+ setup do
+ mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
+ :ok
+ end
+
+ test "Webfinger JRD" do
+ user = insert(:user)
+
+ response =
+ build_conn()
+ |> put_req_header("accept", "application/jrd+json")
+ |> get("/.well-known/webfinger?resource=acct:#{user.nickname}@localhost")
+
+ assert json_response(response, 200)["subject"] == "acct:#{user.nickname}@localhost"
+ end
+
+ test "Webfinger XML" do
+ user = insert(:user)
+
+ response =
+ build_conn()
+ |> put_req_header("accept", "application/jrd+json")
+ |> get("/.well-known/webfinger?resource=acct:#{user.nickname}@localhost")
+
+ assert response(response, 200)
+ end
+end
projects / akkoma / commitdiff