No OneTemporary
Actions

Authored By

Unknown

Size

17 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/mix/pleroma.ex b/lib/mix/pleroma.ex
	index 074492a46..fe9b0d16c 100644
	--- a/lib/mix/pleroma.ex
	+++ b/lib/mix/pleroma.ex
	@@ -1,130 +1,130 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Pleroma do
	@apps [
	:restarter,
	:ecto,
	:ecto_sql,
	:postgrex,
	:db_connection,
	:cachex,
	:flake_id,
	:swoosh,
	:timex
	]
	- @cachex_children ["object", "user"]
	+ @cachex_children ["object", "user", "scrubber"]
	@doc "Common functions to be reused in mix tasks"
	def start_pleroma do
	Pleroma.Config.Holder.save_default()
	Application.put_env(:phoenix, :serve_endpoints, false, persistent: true)

	if Pleroma.Config.get(:env) != :test do
	Application.put_env(:logger, :console, level: :debug)
	end

	adapter = Application.get_env(:tesla, :adapter)

	apps =
	if adapter == Tesla.Adapter.Gun do
	[:gun \| @apps]
	else
	[:hackney \| @apps]
	end

	Enum.each(apps, &Application.ensure_all_started/1)

	children =
	[
	Pleroma.Repo,
	{Pleroma.Config.TransferTask, false},
	Pleroma.Web.Endpoint,
	{Oban, Pleroma.Config.get(Oban)}
	] ++
	http_children(adapter)

	cachex_children = Enum.map(@cachex_children, &Pleroma.Application.build_cachex(&1, []))

	Supervisor.start_link(children ++ cachex_children,
	strategy: :one_for_one,
	name: Pleroma.Supervisor
	)

	if Pleroma.Config.get(:env) not in [:test, :benchmark] do
	pleroma_rebooted?()
	end
	end

	defp pleroma_rebooted? do
	if Restarter.Pleroma.rebooted?() do
	:ok
	else
	Process.sleep(10)
	pleroma_rebooted?()
	end
	end

	def load_pleroma do
	Application.load(:pleroma)
	end

	def get_option(options, opt, prompt, defval \\ nil, defname \\ nil) do
	Keyword.get(options, opt) \|\| shell_prompt(prompt, defval, defname)
	end

	def shell_prompt(prompt, defval \\ nil, defname \\ nil) do
	prompt_message = "#{prompt} [#{defname \|\| defval}] "

	input =
	if mix_shell?(),
	do: Mix.shell().prompt(prompt_message),
	else: :io.get_line(prompt_message)

	case input do
	"\n" ->
	case defval do
	nil ->
	shell_prompt(prompt, defval, defname)

	defval ->
	defval
	end

	input ->
	String.trim(input)
	end
	end

	def shell_yes?(message) do
	if mix_shell?(),
	do: Mix.shell().yes?("Continue?"),
	else: shell_prompt(message, "Continue?") in ~w(Yn Y y)
	end

	def shell_info(message) do
	if mix_shell?(),
	do: Mix.shell().info(message),
	else: IO.puts(message)
	end

	def shell_error(message) do
	if mix_shell?(),
	do: Mix.shell().error(message),
	else: IO.puts(:stderr, message)
	end

	@doc "Performs a safe check whether `Mix.shell/0` is available (does not raise if Mix is not loaded)"
	def mix_shell?, do: :erlang.function_exported(Mix, :shell, 0)

	def escape_sh_path(path) do
	~S(') <> String.replace(path, ~S('), ~S(\')) <> ~S(')
	end

	defp http_children(Tesla.Adapter.Gun) do
	Pleroma.Gun.ConnectionPool.children() ++
	[{Task, &Pleroma.HTTP.AdapterHelper.Gun.limiter_setup/0}]
	end

	defp http_children(_), do: []
	end
	diff --git a/lib/mix/tasks/pleroma/emoji.ex b/lib/mix/tasks/pleroma/emoji.ex
	index f4eaeac98..8f52ee98d 100644
	--- a/lib/mix/tasks/pleroma/emoji.ex
	+++ b/lib/mix/tasks/pleroma/emoji.ex
	@@ -1,281 +1,283 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Emoji do
	use Mix.Task
	import Mix.Pleroma

	@shortdoc "Manages emoji packs"
	@moduledoc File.read!("docs/administration/CLI_tasks/emoji.md")

	def run(["ls-packs" \| args]) do
	start_pleroma()

	{options, [], []} = parse_global_opts(args)

	url_or_path = options[:manifest] \|\| default_manifest()
	- manifest = fetch_and_decode(url_or_path)
	+ manifest = fetch_and_decode!(url_or_path)

	Enum.each(manifest, fn {name, info} ->
	to_print = [
	{"Name", name},
	{"Homepage", info["homepage"]},
	{"Description", info["description"]},
	{"License", info["license"]},
	{"Source", info["src"]}
	]

	for {param, value} <- to_print do
	IO.puts(IO.ANSI.format([:bright, param, :normal, ": ", value]))
	end

	# A newline
	IO.puts("")
	end)
	end

	def run(["get-packs" \| args]) do
	start_pleroma()

	{options, pack_names, []} = parse_global_opts(args)

	url_or_path = options[:manifest] \|\| default_manifest()

	- manifest = fetch_and_decode(url_or_path)
	+ manifest = fetch_and_decode!(url_or_path)

	for pack_name <- pack_names do
	if Map.has_key?(manifest, pack_name) do
	pack = manifest[pack_name]
	src = pack["src"]

	IO.puts(
	IO.ANSI.format([
	"Downloading ",
	:bright,
	pack_name,
	:normal,
	" from ",
	:underline,
	src
	])
	)

	{:ok, binary_archive} = fetch(src)
	archive_sha = :crypto.hash(:sha256, binary_archive) \|> Base.encode16()

	sha_status_text = ["SHA256 of ", :bright, pack_name, :normal, " source file is ", :bright]

	if archive_sha == String.upcase(pack["src_sha256"]) do
	IO.puts(IO.ANSI.format(sha_status_text ++ [:green, "OK"]))
	else
	IO.puts(IO.ANSI.format(sha_status_text ++ [:red, "BAD"]))

	raise "Bad SHA256 for #{pack_name}"
	end

	# The location specified in files should be in the same directory
	files_loc =
	url_or_path
	\|> Path.dirname()
	\|> Path.join(pack["files"])

	IO.puts(
	IO.ANSI.format([
	"Fetching the file list for ",
	:bright,
	pack_name,
	:normal,
	" from ",
	:underline,
	files_loc
	])
	)

	- files = fetch_and_decode(files_loc)
	+ files = fetch_and_decode!(files_loc)

	IO.puts(IO.ANSI.format(["Unpacking ", :bright, pack_name]))

	pack_path =
	Path.join([
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji",
	pack_name
	])

	files_to_unzip =
	Enum.map(
	files,
	fn {_, f} -> to_charlist(f) end
	)

	{:ok, _} =
	:zip.unzip(binary_archive,
	cwd: pack_path,
	file_list: files_to_unzip
	)

	IO.puts(IO.ANSI.format(["Writing pack.json for ", :bright, pack_name]))

	pack_json = %{
	pack: %{
	"license" => pack["license"],
	"homepage" => pack["homepage"],
	"description" => pack["description"],
	"fallback-src" => pack["src"],
	"fallback-src-sha256" => pack["src_sha256"],
	"share-files" => true
	},
	files: files
	}

	File.write!(Path.join(pack_path, "pack.json"), Jason.encode!(pack_json, pretty: true))
	else
	IO.puts(IO.ANSI.format([:bright, :red, "No pack named \"#{pack_name}\" found"]))
	end
	end
	end

	def run(["gen-pack" \| args]) do
	start_pleroma()

	{opts, [src], []} =
	OptionParser.parse(
	args,
	strict: [
	name: :string,
	license: :string,
	homepage: :string,
	description: :string,
	files: :string,
	extensions: :string
	]
	)

	proposed_name = Path.basename(src) \|> Path.rootname()
	name = get_option(opts, :name, "Pack name:", proposed_name)
	license = get_option(opts, :license, "License:")
	homepage = get_option(opts, :homepage, "Homepage:")
	description = get_option(opts, :description, "Description:")

	proposed_files_name = "#{name}_files.json"
	files_name = get_option(opts, :files, "Save file list to:", proposed_files_name)

	default_exts = [".png", ".gif"]

	custom_exts =
	get_option(
	opts,
	:extensions,
	"Emoji file extensions (separated with spaces):",
	Enum.join(default_exts, " ")
	)
	\|> String.split(" ", trim: true)

	exts =
	if MapSet.equal?(MapSet.new(default_exts), MapSet.new(custom_exts)) do
	default_exts
	else
	custom_exts
	end

	IO.puts("Using #{Enum.join(exts, " ")} extensions")

	IO.puts("Downloading the pack and generating SHA256")

	binary_archive = Tesla.get!(client(), src).body
	archive_sha = :crypto.hash(:sha256, binary_archive) \|> Base.encode16()

	IO.puts("SHA256 is #{archive_sha}")

	pack_json = %{
	name => %{
	license: license,
	homepage: homepage,
	description: description,
	src: src,
	src_sha256: archive_sha,
	files: files_name
	}
	}

	tmp_pack_dir = Path.join(System.tmp_dir!(), "emoji-pack-#{name}")

	{:ok, _} = :zip.unzip(binary_archive, cwd: String.to_charlist(tmp_pack_dir))

	emoji_map = Pleroma.Emoji.Loader.make_shortcode_to_file_map(tmp_pack_dir, exts)

	File.write!(files_name, Jason.encode!(emoji_map, pretty: true))

	IO.puts("""

	#{files_name} has been created and contains the list of all found emojis in the pack.
	Please review the files in the pack and remove those not needed.
	""")

	pack_file = "#{name}.json"

	if File.exists?(pack_file) do
	existing_data = File.read!(pack_file) \|> Jason.decode!()

	File.write!(
	pack_file,
	Jason.encode!(
	Map.merge(
	existing_data,
	pack_json
	),
	pretty: true
	)
	)

	IO.puts("#{pack_file} has been updated with the #{name} pack")
	else
	File.write!(pack_file, Jason.encode!(pack_json, pretty: true))

	IO.puts("#{pack_file} has been created with the #{name} pack")
	end
	end

	def run(["reload"]) do
	start_pleroma()
	Pleroma.Emoji.reload()
	IO.puts("Emoji packs have been reloaded.")
	end

	- defp fetch_and_decode(from) do
	+ defp fetch_and_decode!(from) do
	with {:ok, json} <- fetch(from) do
	Jason.decode!(json)
	+ else
	+ {:error, error} -> raise "#{from} cannot be fetched. Error: #{error} occur."
	end
	end

	defp fetch("http" <> _ = from) do
	with {:ok, %{body: body}} <- Tesla.get(client(), from) do
	{:ok, body}
	end
	end

	defp fetch(path), do: File.read(path)

	defp parse_global_opts(args) do
	OptionParser.parse(
	args,
	strict: [
	manifest: :string
	],
	aliases: [
	m: :manifest
	]
	)
	end

	defp client do
	middleware = [
	{Tesla.Middleware.FollowRedirects, [max_redirects: 3]}
	]

	Tesla.client(middleware)
	end

	defp default_manifest, do: Pleroma.Config.get!([:emoji, :default_manifest])
	end
	diff --git a/lib/pleroma/emails/user_email.ex b/lib/pleroma/emails/user_email.ex
	index 313533859..1d8c72ae9 100644
	--- a/lib/pleroma/emails/user_email.ex
	+++ b/lib/pleroma/emails/user_email.ex
	@@ -1,183 +1,192 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emails.UserEmail do
	@moduledoc "User emails"

	use Phoenix.Swoosh, view: Pleroma.Web.EmailView, layout: {Pleroma.Web.LayoutView, :email}

	alias Pleroma.Config
	alias Pleroma.User
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router

	import Pleroma.Config.Helpers, only: [instance_name: 0, sender: 0]

	defp recipient(email, nil), do: email
	defp recipient(email, name), do: {name, email}
	defp recipient(%User{} = user), do: recipient(user.email, user.name)

	@spec welcome(User.t(), map()) :: Swoosh.Email.t()
	def welcome(user, opts \\ %{}) do
	new()
	\|> to(recipient(user))
	\|> from(Map.get(opts, :sender, sender()))
	\|> subject(Map.get(opts, :subject, "Welcome to #{instance_name()}!"))
	\|> html_body(Map.get(opts, :html, "Welcome to #{instance_name()}!"))
	\|> text_body(Map.get(opts, :text, "Welcome to #{instance_name()}!"))
	end

	def password_reset_email(user, token) when is_binary(token) do
	password_reset_url = Router.Helpers.reset_password_url(Endpoint, :reset, token)

	html_body = """
	<h3>Reset your password at #{instance_name()}</h3>
	<p>Someone has requested password change for your account at #{instance_name()}.</p>
	<p>If it was you, visit the following link to proceed: <a href="#{password_reset_url}">reset password</a>.</p>
	<p>If it was someone else, nothing to worry about: your data is secure and your password has not been changed.</p>
	"""

	new()
	\|> to(recipient(user))
	\|> from(sender())
	\|> 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

	def account_confirmation_email(user) do
	confirmation_url =
	Router.Helpers.confirm_email_url(
	Endpoint,
	:confirm_email,
	user.id,
	to_string(user.confirmation_token)
	)

	html_body = """
	<h3>Welcome to #{instance_name()}!</h3>
	<p>Email confirmation is required to activate the account.</p>
	<p>Click the following link to proceed: <a href="#{confirmation_url}">activate your account</a>.</p>
	"""

	new()
	\|> to(recipient(user))
	\|> from(sender())
	\|> subject("#{instance_name()} account confirmation")
	\|> html_body(html_body)
	end

	@doc """
	Email used in digest email notifications
	Includes Mentions and New Followers data
	If there are no mentions (even when new followers exist), the function will return nil
	"""
	@spec digest_email(User.t()) :: Swoosh.Email.t() \| nil
	def digest_email(user) do
	notifications = Pleroma.Notification.for_user_since(user, user.last_digest_emailed_at)

	mentions =
	notifications
	\|> Enum.filter(&(&1.activity.data["type"] == "Create"))
	\|> Enum.map(fn notification ->
	object = Pleroma.Object.normalize(notification.activity)
	- object = update_in(object.data["content"], &format_links/1)

	- %{
	- data: notification,
	- object: object,
	- from: User.get_by_ap_id(notification.activity.actor)
	- }
	+ if not is_nil(object) do
	+ object = update_in(object.data["content"], &format_links/1)
	+
	+ %{
	+ data: notification,
	+ object: object,
	+ from: User.get_by_ap_id(notification.activity.actor)
	+ }
	+ end
	end)
	+ \|> Enum.filter(& &1)

	followers =
	notifications
	\|> Enum.filter(&(&1.activity.data["type"] == "Follow"))
	\|> Enum.map(fn notification ->
	- %{
	- data: notification,
	- object: Pleroma.Object.normalize(notification.activity),
	- from: User.get_by_ap_id(notification.activity.actor)
	- }
	+ from = User.get_by_ap_id(notification.activity.actor)
	+
	+ if not is_nil(from) do
	+ %{
	+ data: notification,
	+ object: Pleroma.Object.normalize(notification.activity),
	+ from: User.get_by_ap_id(notification.activity.actor)
	+ }
	+ end
	end)
	+ \|> Enum.filter(& &1)

	unless Enum.empty?(mentions) do
	styling = Config.get([__MODULE__, :styling])
	logo = Config.get([__MODULE__, :logo])

	html_data = %{
	instance: instance_name(),
	user: user,
	mentions: mentions,
	followers: followers,
	unsubscribe_link: unsubscribe_url(user, "digest"),
	styling: styling
	}

	logo_path =
	if is_nil(logo) do
	Path.join(:code.priv_dir(:pleroma), "static/static/logo.png")
	else
	Path.join(Config.get([:instance, :static_dir]), logo)
	end

	new()
	\|> to(recipient(user))
	\|> from(sender())
	\|> subject("Your digest from #{instance_name()}")
	\|> put_layout(false)
	\|> render_body("digest.html", html_data)
	\|> attachment(Swoosh.Attachment.new(logo_path, filename: "logo.png", type: :inline))
	end
	end

	defp format_links(str) do
	re = ~r/<a.+href=['"].*>/iU
	%{link_color: color} = Config.get([__MODULE__, :styling])

	Regex.replace(re, str, fn link ->
	String.replace(link, "<a", "<a style=\"color: #{color};text-decoration: none;\"")
	end)
	end

	@doc """
	Generate unsubscribe link for given user and notifications type.
	The link contains JWT token with the data, and subscription can be modified without
	authorization.
	"""
	@spec unsubscribe_url(User.t(), String.t()) :: String.t()
	def unsubscribe_url(user, notifications_type) do
	token =
	%{"sub" => user.id, "act" => %{"unsubscribe" => notifications_type}, "exp" => false}
	\|> Pleroma.JWT.generate_and_sign!()
	\|> Base.encode64()

	Router.Helpers.subscription_url(Endpoint, :unsubscribe, token)
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 2:04 AM (19 h, 18 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802208
Default Alt Text: (17 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions