1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.TwitterAPI.UtilController do
6 use Pleroma.Web, :controller
10 alias Pleroma.Activity
12 alias Pleroma.Notification
13 alias Pleroma.Plugs.AuthenticationPlug
16 alias Pleroma.Web.ActivityPub.ActivityPub
17 alias Pleroma.Web.CommonAPI
18 alias Pleroma.Web.OStatus
19 alias Pleroma.Web.WebFinger
21 def help_test(conn, _params) do
25 def remote_subscribe(conn, %{"nickname" => nick, "profile" => _}) do
26 with %User{} = user <- User.get_cached_by_nickname(nick), avatar = User.avatar_url(user) do
28 |> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
31 render(conn, "subscribe.html", %{
34 error: "Could not find user"
39 def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
40 with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
41 %User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
43 |> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
46 render(conn, "subscribe.html", %{
49 error: "Something went wrong."
54 def remote_follow(%{assigns: %{user: user}} = conn, %{"acct" => acct}) do
55 if is_status?(acct) do
56 {:ok, object} = Pleroma.Object.Fetcher.fetch_object_from_id(acct)
57 %Activity{id: activity_id} = Activity.get_create_by_object_ap_id(object.data["id"])
58 redirect(conn, to: "/notice/#{activity_id}")
60 {err, followee} = OStatus.find_or_make_user(acct)
61 avatar = User.avatar_url(followee)
62 name = followee.nickname
67 |> render("follow.html", %{error: err, acct: acct, avatar: avatar, name: name, id: id})
70 |> render("follow_login.html", %{
81 defp is_status?(acct) do
82 case Pleroma.Object.Fetcher.fetch_and_contain_remote_object_from_id(acct) do
83 {:ok, %{"type" => type}} when type in ["Article", "Note", "Video", "Page", "Question"] ->
91 def do_remote_follow(conn, %{
92 "authorization" => %{"name" => username, "password" => password, "id" => id}
94 followee = User.get_cached_by_id(id)
95 avatar = User.avatar_url(followee)
96 name = followee.nickname
98 with %User{} = user <- User.get_cached_by_nickname(username),
99 true <- AuthenticationPlug.checkpw(password, user.password_hash),
100 %User{} = _followed <- User.get_cached_by_id(id),
101 {:ok, follower} <- User.follow(user, followee),
102 {:ok, _activity} <- ActivityPub.follow(follower, followee) do
104 |> render("followed.html", %{error: false})
106 # Was already following user
107 {:error, "Could not follow user:" <> _rest} ->
108 render(conn, "followed.html", %{error: false})
112 |> render("follow_login.html", %{
113 error: "Wrong username or password",
121 def do_remote_follow(%{assigns: %{user: user}} = conn, %{"user" => %{"id" => id}}) do
122 with %User{} = followee <- User.get_cached_by_id(id),
123 {:ok, follower} <- User.follow(user, followee),
124 {:ok, _activity} <- ActivityPub.follow(follower, followee) do
126 |> render("followed.html", %{error: false})
128 # Was already following user
129 {:error, "Could not follow user:" <> _rest} ->
131 |> render("followed.html", %{error: false})
134 Logger.debug("Remote follow failed with error #{inspect(e)}")
137 |> render("followed.html", %{error: inspect(e)})
141 def notifications_read(%{assigns: %{user: user}} = conn, %{"id" => notification_id}) do
142 with {:ok, _} <- Notification.read_one(user, notification_id) do
143 json(conn, %{status: "success"})
147 |> put_resp_content_type("application/json")
148 |> send_resp(403, Jason.encode!(%{"error" => message}))
152 def config(conn, _params) do
153 instance = Pleroma.Config.get(:instance)
155 case get_format(conn) do
160 <name>#{Keyword.get(instance, :name)}</name>
161 <site>#{Web.base_url()}</site>
162 <textlimit>#{Keyword.get(instance, :limit)}</textlimit>
163 <closed>#{!Keyword.get(instance, :registrations_open)}</closed>
169 |> put_resp_content_type("application/xml")
170 |> send_resp(200, response)
173 vapid_public_key = Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
176 uploadlimit: to_string(Keyword.get(instance, :upload_limit)),
177 avatarlimit: to_string(Keyword.get(instance, :avatar_upload_limit)),
178 backgroundlimit: to_string(Keyword.get(instance, :background_upload_limit)),
179 bannerlimit: to_string(Keyword.get(instance, :banner_upload_limit))
183 name: Keyword.get(instance, :name),
184 description: Keyword.get(instance, :description),
185 server: Web.base_url(),
186 textlimit: to_string(Keyword.get(instance, :limit)),
187 uploadlimit: uploadlimit,
188 closed: if(Keyword.get(instance, :registrations_open), do: "0", else: "1"),
189 private: if(Keyword.get(instance, :public, true), do: "0", else: "1"),
190 vapidPublicKey: vapid_public_key,
191 accountActivationRequired:
192 if(Keyword.get(instance, :account_activation_required, false), do: "1", else: "0"),
193 invitesEnabled: if(Keyword.get(instance, :invites_enabled, false), do: "1", else: "0"),
194 safeDMMentionsEnabled:
195 if(Pleroma.Config.get([:instance, :safe_dm_mentions]), do: "1", else: "0")
198 pleroma_fe = Pleroma.Config.get([:frontend_configurations, :pleroma_fe])
200 managed_config = Keyword.get(instance, :managed_config)
204 data |> Map.put("pleromafe", pleroma_fe)
209 json(conn, %{site: data})
213 def frontend_configurations(conn, _params) do
215 Pleroma.Config.get(:frontend_configurations, %{})
221 def version(conn, _params) do
222 version = Pleroma.Application.named_version()
224 case get_format(conn) do
226 response = "<version>#{version}</version>"
229 |> put_resp_content_type("application/xml")
230 |> send_resp(200, response)
237 def emoji(conn, _params) do
240 |> Enum.map(fn {short_code, path, tags} ->
241 {short_code, %{image_url: path, tags: tags}}
248 def update_notificaton_settings(%{assigns: %{user: user}} = conn, params) do
249 with {:ok, _} <- User.update_notification_settings(user, params) do
250 json(conn, %{status: "success"})
254 def follow_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
255 follow_import(conn, %{"list" => File.read!(listfile.path)})
258 def follow_import(%{assigns: %{user: follower}} = conn, %{"list" => list}) do
259 with lines <- String.split(list, "\n"),
260 followed_identifiers <-
261 Enum.map(lines, fn line ->
262 String.split(line, ",") |> List.first()
264 |> List.delete("Account address") do
265 PleromaJobQueue.enqueue(:background, User, [
271 json(conn, "job started")
275 def blocks_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
276 blocks_import(conn, %{"list" => File.read!(listfile.path)})
279 def blocks_import(%{assigns: %{user: blocker}} = conn, %{"list" => list}) do
280 with blocked_identifiers <- String.split(list) do
281 PleromaJobQueue.enqueue(:background, User, [
287 json(conn, "job started")
291 def change_password(%{assigns: %{user: user}} = conn, params) do
292 case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
295 User.reset_password(user, %{
296 password: params["new_password"],
297 password_confirmation: params["new_password_confirmation"]
299 json(conn, %{status: "success"})
301 {:error, changeset} ->
302 {_, {error, _}} = Enum.at(changeset.errors, 0)
303 json(conn, %{error: "New password #{error}."})
306 json(conn, %{error: "Unable to change password."})
310 json(conn, %{error: msg})
314 def delete_account(%{assigns: %{user: user}} = conn, params) do
315 case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
318 json(conn, %{status: "success"})
321 json(conn, %{error: msg})
325 def disable_account(%{assigns: %{user: user}} = conn, params) do
326 case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
328 User.deactivate_async(user)
329 json(conn, %{status: "success"})
332 json(conn, %{error: msg})
336 def captcha(conn, _params) do
337 json(conn, Pleroma.Captcha.new())
340 def healthcheck(conn, _params) do
342 if Pleroma.Config.get([:instance, :healthcheck]) do
343 Pleroma.Healthcheck.system_info()
352 Plug.Conn.put_status(conn, :service_unavailable)