No OneTemporary
Actions

Size

34 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/mix/tasks/pleroma/database.ex b/lib/mix/tasks/pleroma/database.ex
	index 81e687f64..cfd9eeada 100644
	--- a/lib/mix/tasks/pleroma/database.ex
	+++ b/lib/mix/tasks/pleroma/database.ex
	@@ -1,137 +1,138 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Database do
	alias Pleroma.Conversation
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	require Logger
	require Pleroma.Constants
	import Mix.Pleroma
	use Mix.Task

	@shortdoc "A collection of database related tasks"
	+ @moduledoc File.read!("docs/administration/CLI_tasks/database.md")

	def run(["remove_embedded_objects" \| args]) do
	{options, [], []} =
	OptionParser.parse(
	args,
	strict: [
	vacuum: :boolean
	]
	)

	start_pleroma()
	Logger.info("Removing embedded objects")

	Repo.query!(
	"update activities set data = jsonb_set(data, '{object}'::text[], data->'object'->'id') where data->'object'->>'id' is not null;",
	[],
	timeout: :infinity
	)

	if Keyword.get(options, :vacuum) do
	Logger.info("Runnning VACUUM FULL")

	Repo.query!(
	"vacuum full;",
	[],
	timeout: :infinity
	)
	end
	end

	def run(["bump_all_conversations"]) do
	start_pleroma()
	Conversation.bump_for_all_activities()
	end

	def run(["update_users_following_followers_counts"]) do
	start_pleroma()

	users = Repo.all(User)
	Enum.each(users, &User.remove_duplicated_following/1)
	Enum.each(users, &User.update_follower_count/1)
	end

	def run(["prune_objects" \| args]) do
	import Ecto.Query

	{options, [], []} =
	OptionParser.parse(
	args,
	strict: [
	vacuum: :boolean
	]
	)

	start_pleroma()

	deadline = Pleroma.Config.get([:instance, :remote_post_retention_days])

	Logger.info("Pruning objects older than #{deadline} days")

	time_deadline =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(-(deadline * 86_400))

	from(o in Object,
	where:
	fragment(
	"?->'to' \\? ? OR ?->'cc' \\? ?",
	o.data,
	^Pleroma.Constants.as_public(),
	o.data,
	^Pleroma.Constants.as_public()
	),
	where: o.inserted_at < ^time_deadline,
	where:
	fragment("split_part(?->>'actor', '/', 3) != ?", o.data, ^Pleroma.Web.Endpoint.host())
	)
	\|> Repo.delete_all(timeout: :infinity)

	if Keyword.get(options, :vacuum) do
	Logger.info("Runnning VACUUM FULL")

	Repo.query!(
	"vacuum full;",
	[],
	timeout: :infinity
	)
	end
	end

	def run(["fix_likes_collections"]) do
	import Ecto.Query

	start_pleroma()

	from(object in Object,
	where: fragment("(?)->>'likes' is not null", object.data),
	select: %{id: object.id, likes: fragment("(?)->>'likes'", object.data)}
	)
	\|> Pleroma.RepoStreamer.chunk_stream(100)
	\|> Stream.each(fn objects ->
	ids =
	objects
	\|> Enum.filter(fn object -> object.likes \|> Jason.decode!() \|> is_map() end)
	\|> Enum.map(& &1.id)

	Object
	\|> where([object], object.id in ^ids)
	\|> update([object],
	set: [
	data:
	fragment(
	"jsonb_set(?, '{likes}', '[]'::jsonb, true)",
	object.data
	)
	]
	)
	\|> Repo.update_all([], timeout: :infinity)
	end)
	\|> Stream.run()
	end
	end
	diff --git a/lib/mix/tasks/pleroma/digest.ex b/lib/mix/tasks/pleroma/digest.ex
	index 100a81060..7d09e70c5 100644
	--- a/lib/mix/tasks/pleroma/digest.ex
	+++ b/lib/mix/tasks/pleroma/digest.ex
	@@ -1,32 +1,33 @@
	defmodule Mix.Tasks.Pleroma.Digest do
	use Mix.Task

	@shortdoc "Manages digest emails"
	+ @moduledoc File.read!("docs/administration/CLI_tasks/digest.md")

	def run(["test", nickname \| opts]) do
	Mix.Pleroma.start_pleroma()

	user = Pleroma.User.get_by_nickname(nickname)

	last_digest_emailed_at =
	with [date] <- opts,
	{:ok, datetime} <- Timex.parse(date, "{YYYY}-{0M}-{0D}") do
	datetime
	else
	_ -> user.inserted_at
	end

	patched_user = %{user \| last_digest_emailed_at: last_digest_emailed_at}

	with %Swoosh.Email{} = email <- Pleroma.Emails.UserEmail.digest_email(patched_user) do
	{:ok, _} = Pleroma.Emails.Mailer.deliver(email)

	Mix.shell().info("Digest email have been sent to #{nickname} (#{user.email})")
	else
	_ ->
	Mix.shell().info(
	"Cound't find any mentions for #{nickname} since #{last_digest_emailed_at}"
	)
	end
	end
	end
	diff --git a/lib/mix/tasks/pleroma/emoji.ex b/lib/mix/tasks/pleroma/emoji.ex
	index 32b92e6af..6ef0a635d 100644
	--- a/lib/mix/tasks/pleroma/emoji.ex
	+++ b/lib/mix/tasks/pleroma/emoji.ex
	@@ -1,253 +1,254 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

	def run(["ls-packs" \| args]) do
	Application.ensure_all_started(:hackney)

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

	manifest =
	fetch_manifest(if options[:manifest], do: options[:manifest], else: default_manifest())

	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
	Application.ensure_all_started(:hackney)

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

	manifest_url = if options[:manifest], do: options[:manifest], else: default_manifest()

	manifest = fetch_manifest(manifest_url)

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

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

	binary_archive = Tesla.get!(client(), src_url).body
	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 url specified in files should be in the same directory
	files_url = Path.join(Path.dirname(manifest_url), pack["files"])

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

	files = Tesla.get!(client(), files_url).body \|> Jason.decode!()

	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 emoji.txt for ", :bright, pack_name]))

	emoji_txt_str =
	Enum.map(
	files,
	fn {shortcode, path} ->
	emojo_path = Path.join("/emoji/#{pack_name}", path)
	"#{shortcode}, #{emojo_path}"
	end
	)
	\|> Enum.join("\n")

	File.write!(Path.join(pack_path, "emoji.txt"), emoji_txt_str)
	else
	IO.puts(IO.ANSI.format([:bright, :red, "No pack named \"#{pack_name}\" found"]))
	end
	end
	end

	def run(["gen-pack", src]) do
	Application.ensure_all_started(:hackney)

	proposed_name = Path.basename(src) \|> Path.rootname()
	name = String.trim(IO.gets("Pack name [#{proposed_name}]: "))
	# If there's no name, use the default one
	name = if String.length(name) > 0, do: name, else: proposed_name

	license = String.trim(IO.gets("License: "))
	homepage = String.trim(IO.gets("Homepage: "))
	description = String.trim(IO.gets("Description: "))

	proposed_files_name = "#{name}.json"
	files_name = String.trim(IO.gets("Save file list to [#{proposed_files_name}]: "))
	files_name = if String.length(files_name) > 0, do: files_name, else: proposed_files_name

	default_exts = [".png", ".gif"]
	default_exts_str = Enum.join(default_exts, " ")

	exts =
	String.trim(
	IO.gets("Emoji file extensions (separated with spaces) [#{default_exts_str}]: ")
	)

	exts =
	if String.length(exts) > 0 do
	String.split(exts, " ")
	\|> Enum.filter(fn e -> e \|> String.trim() \|> String.length() > 0 end)
	else
	default_exts
	end

	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: 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 remove those not needed.
	""")

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

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

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

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

	defp fetch_manifest(from) do
	Jason.decode!(
	if String.starts_with?(from, "http") do
	Tesla.get!(client(), from).body
	else
	File.read!(from)
	end
	)
	end

	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/mix/tasks/pleroma/instance.ex b/lib/mix/tasks/pleroma/instance.ex
	index 25f94eceb..9af6cda30 100644
	--- a/lib/mix/tasks/pleroma/instance.ex
	+++ b/lib/mix/tasks/pleroma/instance.ex
	@@ -1,238 +1,239 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

	@shortdoc "Manages Pleroma instance"
	+ @moduledoc File.read!("docs/administration/CLI_tasks/instance.md")

	def run(["gen" \| rest]) do
	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [
	force: :boolean,
	output: :string,
	output_psql: :string,
	domain: :string,
	instance_name: :string,
	admin_email: :string,
	notify_email: :string,
	dbhost: :string,
	dbname: :string,
	dbuser: :string,
	dbpass: :string,
	rum: :string,
	indexable: :string,
	db_configurable: :string,
	uploads_dir: :string,
	static_dir: :string,
	listen_ip: :string,
	listen_port: :string
	],
	aliases: [
	o: :output,
	f: :force
	]
	)

	paths =
	[config_path, psql_path] = [
	Keyword.get(options, :output, "config/generated_config.exs"),
	Keyword.get(options, :output_psql, "config/setup_db.psql")
	]

	will_overwrite = Enum.filter(paths, &File.exists?/1)
	proceed? = Enum.empty?(will_overwrite) or Keyword.get(options, :force, false)

	if proceed? do
	[domain, port \| _] =
	String.split(
	get_option(
	options,
	:domain,
	"What domain will your instance use? (e.g pleroma.soykaf.com)"
	),
	":"
	) ++ [443]

	name =
	get_option(
	options,
	:instance_name,
	"What is the name of your instance? (e.g. Pleroma/Soykaf)"
	)

	email = get_option(options, :admin_email, "What is your admin email address?")

	notify_email =
	get_option(
	options,
	:notify_email,
	"What email address do you want to use for sending email notifications?",
	email
	)

	indexable =
	get_option(
	options,
	:indexable,
	"Do you want search engines to index your site? (y/n)",
	"y"
	) === "y"

	db_configurable? =
	get_option(
	options,
	:db_configurable,
	"Do you want to store the configuration in the database (allows controlling it from admin-fe)? (y/n)",
	"n"
	) === "y"

	dbhost = get_option(options, :dbhost, "What is the hostname of your database?", "localhost")

	dbname = get_option(options, :dbname, "What is the name of your database?", "pleroma")

	dbuser =
	get_option(
	options,
	:dbuser,
	"What is the user used to connect to your database?",
	"pleroma"
	)

	dbpass =
	get_option(
	options,
	:dbpass,
	"What is the password used to connect to your database?",
	:crypto.strong_rand_bytes(64) \|> Base.encode64() \|> binary_part(0, 64),
	"autogenerated"
	)

	rum_enabled =
	get_option(
	options,
	:rum,
	"Would you like to use RUM indices?",
	"n"
	) === "y"

	listen_port =
	get_option(
	options,
	:listen_port,
	"What port will the app listen to (leave it if you are using the default setup with nginx)?",
	4000
	)

	listen_ip =
	get_option(
	options,
	:listen_ip,
	"What ip will the app listen to (leave it if you are using the default setup with nginx)?",
	"127.0.0.1"
	)

	uploads_dir =
	get_option(
	options,
	:uploads_dir,
	"What directory should media uploads go in (when using the local uploader)?",
	Pleroma.Config.get([Pleroma.Uploaders.Local, :uploads])
	)

	static_dir =
	get_option(
	options,
	:static_dir,
	"What directory should custom public files be read from (custom emojis, frontend bundle overrides, robots.txt, etc.)?",
	Pleroma.Config.get([:instance, :static_dir])
	)

	secret = :crypto.strong_rand_bytes(64) \|> Base.encode64() \|> binary_part(0, 64)
	jwt_secret = :crypto.strong_rand_bytes(64) \|> Base.encode64() \|> binary_part(0, 64)
	signing_salt = :crypto.strong_rand_bytes(8) \|> Base.encode64() \|> binary_part(0, 8)
	{web_push_public_key, web_push_private_key} = :crypto.generate_key(:ecdh, :prime256v1)
	template_dir = Application.app_dir(:pleroma, "priv") <> "/templates"

	result_config =
	EEx.eval_file(
	template_dir <> "/sample_config.eex",
	domain: domain,
	port: port,
	email: email,
	notify_email: notify_email,
	name: name,
	dbhost: dbhost,
	dbname: dbname,
	dbuser: dbuser,
	dbpass: dbpass,
	secret: secret,
	jwt_secret: jwt_secret,
	signing_salt: signing_salt,
	web_push_public_key: Base.url_encode64(web_push_public_key, padding: false),
	web_push_private_key: Base.url_encode64(web_push_private_key, padding: false),
	db_configurable?: db_configurable?,
	static_dir: static_dir,
	uploads_dir: uploads_dir,
	rum_enabled: rum_enabled,
	listen_ip: listen_ip,
	listen_port: listen_port
	)

	result_psql =
	EEx.eval_file(
	template_dir <> "/sample_psql.eex",
	dbname: dbname,
	dbuser: dbuser,
	dbpass: dbpass,
	rum_enabled: rum_enabled
	)

	shell_info("Writing config to #{config_path}.")

	File.write(config_path, result_config)
	shell_info("Writing the postgres script to #{psql_path}.")
	File.write(psql_path, result_psql)

	write_robots_txt(indexable, template_dir)

	shell_info(
	"\n All files successfully written! Refer to the installation instructions for your platform for next steps"
	)
	else
	shell_error(
	"The task would have overwritten the following files:\n" <>
	(Enum.map(paths, &"- #{&1}\n") \|> Enum.join("")) <>
	"Rerun with `--force` to overwrite them."
	)
	end
	end

	defp write_robots_txt(indexable, template_dir) do
	robots_txt =
	EEx.eval_file(
	template_dir <> "/robots_txt.eex",
	indexable: indexable
	)

	static_dir = Pleroma.Config.get([:instance, :static_dir], "instance/static/")

	unless File.exists?(static_dir) do
	File.mkdir_p!(static_dir)
	end

	robots_txt_path = Path.join(static_dir, "robots.txt")

	if File.exists?(robots_txt_path) do
	File.cp!(robots_txt_path, "#{robots_txt_path}.bak")
	shell_info("Backing up existing robots.txt to #{robots_txt_path}.bak")
	end

	File.write(robots_txt_path, robots_txt)
	shell_info("Writing #{robots_txt_path}.")
	end
	end
	diff --git a/lib/mix/tasks/pleroma/relay.ex b/lib/mix/tasks/pleroma/relay.ex
	index 519f2d1b5..d7a7b599f 100644
	--- a/lib/mix/tasks/pleroma/relay.ex
	+++ b/lib/mix/tasks/pleroma/relay.ex
	@@ -1,47 +1,48 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Relay do
	use Mix.Task
	import Mix.Pleroma
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay

	@shortdoc "Manages remote relays"
	+ @moduledoc File.read!("docs/administration/CLI_tasks/relay.md")

	def run(["follow", target]) do
	start_pleroma()

	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
	{:error, e} -> shell_error("Error while following #{target}: #{inspect(e)}")
	end
	end

	def run(["unfollow", target]) do
	start_pleroma()

	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
	{:error, e} -> shell_error("Error while following #{target}: #{inspect(e)}")
	end
	end

	def run(["list"]) do
	start_pleroma()

	with %User{following: following} = _user <- Relay.get_actor() do
	following
	\|> Enum.map(fn entry -> URI.parse(entry).host end)
	\|> Enum.uniq()
	\|> Enum.each(&shell_info(&1))
	else
	e -> shell_error("Error while fetching relay subscription list: #{inspect(e)}")
	end
	end
	end
	diff --git a/lib/mix/tasks/pleroma/uploads.ex b/lib/mix/tasks/pleroma/uploads.ex
	index bc2248a76..3e6fc7ee0 100644
	--- a/lib/mix/tasks/pleroma/uploads.ex
	+++ b/lib/mix/tasks/pleroma/uploads.ex
	@@ -1,99 +1,100 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Uploads do
	use Mix.Task
	import Mix.Pleroma
	alias Pleroma.Upload
	alias Pleroma.Uploaders.Local
	require Logger

	@log_every 50

	@shortdoc "Migrates uploads from local to remote storage"
	+ @moduledoc File.read!("docs/administration/CLI_tasks/uploads.md")

	def run(["migrate_local", target_uploader \| args]) do
	delete? = Enum.member?(args, "--delete")
	start_pleroma()
	local_path = Pleroma.Config.get!([Local, :uploads])
	uploader = Module.concat(Pleroma.Uploaders, target_uploader)

	unless Code.ensure_loaded?(uploader) do
	raise("The uploader #{inspect(uploader)} is not an existing/loaded module.")
	end

	target_enabled? = Pleroma.Config.get([Upload, :uploader]) == uploader

	unless target_enabled? do
	Pleroma.Config.put([Upload, :uploader], uploader)
	end

	shell_info("Migrating files from local #{local_path} to #{to_string(uploader)}")

	if delete? do
	shell_info(
	"Attention: uploaded files will be deleted, hope you have backups! (--delete ; cancel with ^C)"
	)

	:timer.sleep(:timer.seconds(5))
	end

	uploads =
	File.ls!(local_path)
	\|> Enum.map(fn id ->
	root_path = Path.join(local_path, id)

	cond do
	File.dir?(root_path) ->
	files = for file <- File.ls!(root_path), do: {id, file, Path.join([root_path, file])}

	case List.first(files) do
	{id, file, path} ->
	{%Pleroma.Upload{id: id, name: file, path: id <> "/" <> file, tempfile: path},
	root_path}

	_ ->
	nil
	end

	File.exists?(root_path) ->
	file = Path.basename(id)
	hash = Path.rootname(id)
	{%Pleroma.Upload{id: hash, name: file, path: file, tempfile: root_path}, root_path}

	true ->
	nil
	end
	end)
	\|> Enum.filter(& &1)

	total_count = length(uploads)
	shell_info("Found #{total_count} uploads")

	uploads
	\|> Task.async_stream(
	fn {upload, root_path} ->
	case Upload.store(upload, uploader: uploader, filters: [], size_limit: nil) do
	{:ok, _} ->
	if delete?, do: File.rm_rf!(root_path)
	Logger.debug("uploaded: #{inspect(upload.path)} #{inspect(upload)}")
	:ok

	error ->
	shell_error("failed to upload #{inspect(upload.path)}: #{inspect(error)}")
	end
	end,
	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)
	shell_info("Uploaded #{count}/#{total_count} files")
	count
	end)

	shell_info("Done!")
	end
	end
	diff --git a/lib/mix/tasks/pleroma/user.ex b/lib/mix/tasks/pleroma/user.ex
	index 3cf3ad2c6..134b5bccc 100644
	--- a/lib/mix/tasks/pleroma/user.ex
	+++ b/lib/mix/tasks/pleroma/user.ex
	@@ -1,385 +1,386 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.User do
	use Mix.Task
	import Mix.Pleroma
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.OAuth

	@shortdoc "Manages Pleroma users"
	+ @moduledoc File.read!("docs/administration/CLI_tasks/user.md")

	def run(["new", nickname, email \| rest]) do
	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [
	name: :string,
	bio: :string,
	password: :string,
	moderator: :boolean,
	admin: :boolean,
	assume_yes: :boolean
	],
	aliases: [
	y: :assume_yes
	]
	)

	name = Keyword.get(options, :name, nickname)
	bio = Keyword.get(options, :bio, "")

	{password, generated_password?} =
	case Keyword.get(options, :password) do
	nil ->
	{:crypto.strong_rand_bytes(16) \|> Base.encode64(), true}

	password ->
	{password, false}
	end

	moderator? = Keyword.get(options, :moderator, false)
	admin? = Keyword.get(options, :admin, false)
	assume_yes? = Keyword.get(options, :assume_yes, false)

	shell_info("""
	A user will be created with the following information:
	- nickname: #{nickname}
	- email: #{email}
	- password: #{
	if(generated_password?, do: "[generated; a reset link will be created]", else: password)
	}
	- name: #{name}
	- bio: #{bio}
	- moderator: #{if(moderator?, do: "true", else: "false")}
	- admin: #{if(admin?, do: "true", else: "false")}
	""")

	proceed? = assume_yes? or shell_yes?("Continue?")

	if proceed? do
	start_pleroma()

	params = %{
	nickname: nickname,
	email: email,
	password: password,
	password_confirmation: password,
	name: name,
	bio: bio
	}

	changeset = User.register_changeset(%User{}, params, need_confirmation: false)
	{:ok, _user} = User.register(changeset)

	shell_info("User #{nickname} created")

	if moderator? do
	run(["set", nickname, "--moderator"])
	end

	if admin? do
	run(["set", nickname, "--admin"])
	end

	if generated_password? do
	run(["reset_password", nickname])
	end
	else
	shell_info("User will not be created.")
	end
	end

	def run(["rm", nickname]) do
	start_pleroma()

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	User.perform(:delete, user)
	shell_info("User #{nickname} deleted.")
	else
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

	def run(["toggle_activated", nickname]) do
	start_pleroma()

	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	{:ok, user} = User.deactivate(user, !user.info.deactivated)

	shell_info(
	"Activation status of #{nickname}: #{if(user.info.deactivated, do: "de", else: "")}activated"
	)
	else
	_ ->
	shell_error("No user #{nickname}")
	end
	end

	def run(["reset_password", nickname]) do
	start_pleroma()

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname),
	{:ok, token} <- Pleroma.PasswordResetToken.create_token(user) do
	shell_info("Generated password reset token for #{user.nickname}")

	IO.puts(
	"URL: #{
	Pleroma.Web.Router.Helpers.reset_password_url(
	Pleroma.Web.Endpoint,
	:reset,
	token.token
	)
	}"
	)
	else
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

	def run(["unsubscribe", nickname]) do
	start_pleroma()

	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	shell_info("Deactivating #{user.nickname}")
	User.deactivate(user)

	user
	\|> User.get_friends()
	\|> Enum.each(fn friend ->
	user = User.get_cached_by_id(user.id)

	shell_info("Unsubscribing #{friend.nickname} from #{user.nickname}")
	User.unfollow(user, friend)
	end)

	:timer.sleep(500)

	user = User.get_cached_by_id(user.id)

	if Enum.empty?(user.following) do
	shell_info("Successfully unsubscribed all followers from #{user.nickname}")
	end
	else
	_ ->
	shell_error("No user #{nickname}")
	end
	end

	def run(["unsubscribe_all_from_instance", instance]) do
	start_pleroma()

	Pleroma.User.Query.build(%{nickname: "@#{instance}"})
	\|> Pleroma.RepoStreamer.chunk_stream(500)
	\|> Stream.each(fn users ->
	users
	\|> Enum.each(fn user ->
	run(["unsubscribe", user.nickname])
	end)
	end)
	\|> Stream.run()
	end

	def run(["set", nickname \| rest]) do
	start_pleroma()

	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [
	moderator: :boolean,
	admin: :boolean,
	locked: :boolean
	]
	)

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	user =
	case Keyword.get(options, :moderator) do
	nil -> user
	value -> set_moderator(user, value)
	end

	user =
	case Keyword.get(options, :locked) do
	nil -> user
	value -> set_locked(user, value)
	end

	_user =
	case Keyword.get(options, :admin) do
	nil -> user
	value -> set_admin(user, value)
	end
	else
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

	def run(["tag", nickname \| tags]) do
	start_pleroma()

	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	user = user \|> User.tag(tags)

	shell_info("Tags of #{user.nickname}: #{inspect(tags)}")
	else
	_ ->
	shell_error("Could not change user tags for #{nickname}")
	end
	end

	def run(["untag", nickname \| tags]) do
	start_pleroma()

	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	user = user \|> User.untag(tags)

	shell_info("Tags of #{user.nickname}: #{inspect(tags)}")
	else
	_ ->
	shell_error("Could not change user tags for #{nickname}")
	end
	end

	def run(["invite" \| rest]) do
	{options, [], []} =
	OptionParser.parse(rest,
	strict: [
	expires_at: :string,
	max_use: :integer
	]
	)

	options =
	options
	\|> Keyword.update(:expires_at, {:ok, nil}, fn
	nil -> {:ok, nil}
	val -> Date.from_iso8601(val)
	end)
	\|> Enum.into(%{})

	start_pleroma()

	with {:ok, val} <- options[:expires_at],
	options = Map.put(options, :expires_at, val),
	{:ok, invite} <- UserInviteToken.create_invite(options) do
	shell_info("Generated user invite token " <> String.replace(invite.invite_type, "_", " "))

	url =
	Pleroma.Web.Router.Helpers.redirect_url(
	Pleroma.Web.Endpoint,
	:registration_page,
	invite.token
	)

	IO.puts(url)
	else
	error ->
	shell_error("Could not create invite token: #{inspect(error)}")
	end
	end

	def run(["invites"]) do
	start_pleroma()

	shell_info("Invites list:")

	UserInviteToken.list_invites()
	\|> Enum.each(fn invite ->
	expire_info =
	with expires_at when not is_nil(expires_at) <- invite.expires_at do
	" \| Expires at: #{Date.to_string(expires_at)}"
	end

	using_info =
	with max_use when not is_nil(max_use) <- invite.max_use do
	" \| Max use: #{max_use} Left use: #{max_use - invite.uses}"
	end

	shell_info(
	"ID: #{invite.id} \| Token: #{invite.token} \| Token type: #{invite.invite_type} \| Used: #{
	invite.used
	}#{expire_info}#{using_info}"
	)
	end)
	end

	def run(["revoke_invite", token]) do
	start_pleroma()

	with {:ok, invite} <- UserInviteToken.find_by_token(token),
	{:ok, _} <- UserInviteToken.update_invite(invite, %{used: true}) do
	shell_info("Invite for token #{token} was revoked.")
	else
	_ -> shell_error("No invite found with token #{token}")
	end
	end

	def run(["delete_activities", nickname]) do
	start_pleroma()

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	User.delete_user_activities(user)
	shell_info("User #{nickname} statuses deleted.")
	else
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

	def run(["toggle_confirmed", nickname]) do
	start_pleroma()

	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	{:ok, user} = User.toggle_confirmation(user)

	message = if user.info.confirmation_pending, do: "needs", else: "doesn't need"

	shell_info("#{nickname} #{message} confirmation.")
	else
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

	def run(["sign_out", nickname]) do
	start_pleroma()

	with %User{local: true} = user <- User.get_cached_by_nickname(nickname) do
	OAuth.Token.delete_user_tokens(user)
	OAuth.Authorization.delete_user_authorizations(user)

	shell_info("#{nickname} signed out from all apps.")
	else
	_ ->
	shell_error("No local user #{nickname}")
	end
	end

	defp set_moderator(user, value) do
	{:ok, user} = User.update_info(user, &User.Info.admin_api_update(&1, %{is_moderator: value}))

	shell_info("Moderator status of #{user.nickname}: #{user.info.is_moderator}")
	user
	end

	defp set_admin(user, value) do
	{:ok, user} = User.update_info(user, &User.Info.admin_api_update(&1, %{is_admin: value}))

	shell_info("Admin status of #{user.nickname}: #{user.info.is_admin}")
	user
	end

	defp set_locked(user, value) do
	{:ok, user} = User.update_info(user, &User.Info.user_upgrade(&1, %{locked: value}))

	shell_info("Locked status of #{user.nickname}: #{user.info.locked}")
	user
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Jun 4, 6:38 PM (1 d, 9 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1539155
Default Alt Text: (34 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions