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
13 alias Pleroma.Healthcheck
14 alias Pleroma.Notification
15 alias Pleroma.Plugs.AuthenticationPlug
18 alias Pleroma.Web.CommonAPI
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),
27 avatar = User.avatar_url(user) do
29 |> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
32 render(conn, "subscribe.html", %{
35 error: "Could not find user"
40 def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
41 with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
42 %User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
44 |> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
47 render(conn, "subscribe.html", %{
50 error: "Something went wrong."
55 def remote_follow(%{assigns: %{user: user}} = conn, %{"acct" => acct}) do
56 if is_status?(acct) do
57 {:ok, object} = Pleroma.Object.Fetcher.fetch_object_from_id(acct)
58 %Activity{id: activity_id} = Activity.get_create_by_object_ap_id(object.data["id"])
59 redirect(conn, to: "/notice/#{activity_id}")
61 {err, followee} = User.get_or_fetch(acct)
62 avatar = User.avatar_url(followee)
63 name = followee.nickname
68 |> render("follow.html", %{error: err, acct: acct, avatar: avatar, name: name, id: id})
71 |> render("follow_login.html", %{
82 defp is_status?(acct) do
83 case Pleroma.Object.Fetcher.fetch_and_contain_remote_object_from_id(acct) do
84 {:ok, %{"type" => type}} when type in ["Article", "Note", "Video", "Page", "Question"] ->
92 def do_remote_follow(conn, %{
93 "authorization" => %{"name" => username, "password" => password, "id" => id}
95 followee = User.get_cached_by_id(id)
96 avatar = User.avatar_url(followee)
97 name = followee.nickname
99 with %User{} = user <- User.get_cached_by_nickname(username),
100 true <- AuthenticationPlug.checkpw(password, user.password_hash),
101 %User{} = _followed <- User.get_cached_by_id(id),
102 {:ok, _follower, _followee, _activity} <- CommonAPI.follow(user, 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, _followee, _activity} <- CommonAPI.follow(user, followee) do
125 |> render("followed.html", %{error: false})
127 # Was already following user
128 {:error, "Could not follow user:" <> _rest} ->
130 |> render("followed.html", %{error: false})
133 Logger.debug("Remote follow failed with error #{inspect(e)}")
136 |> render("followed.html", %{error: inspect(e)})
140 def notifications_read(%{assigns: %{user: user}} = conn, %{"id" => notification_id}) do
141 with {:ok, _} <- Notification.read_one(user, notification_id) do
142 json(conn, %{status: "success"})
146 |> put_resp_content_type("application/json")
147 |> send_resp(403, Jason.encode!(%{"error" => message}))
151 def config(conn, _params) do
152 instance = Pleroma.Config.get(:instance)
154 case get_format(conn) do
159 <name>#{Keyword.get(instance, :name)}</name>
160 <site>#{Web.base_url()}</site>
161 <textlimit>#{Keyword.get(instance, :limit)}</textlimit>
162 <closed>#{!Keyword.get(instance, :registrations_open)}</closed>
168 |> put_resp_content_type("application/xml")
169 |> send_resp(200, response)
172 vapid_public_key = Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
175 uploadlimit: to_string(Keyword.get(instance, :upload_limit)),
176 avatarlimit: to_string(Keyword.get(instance, :avatar_upload_limit)),
177 backgroundlimit: to_string(Keyword.get(instance, :background_upload_limit)),
178 bannerlimit: to_string(Keyword.get(instance, :banner_upload_limit))
182 name: Keyword.get(instance, :name),
183 description: Keyword.get(instance, :description),
184 server: Web.base_url(),
185 textlimit: to_string(Keyword.get(instance, :limit)),
186 uploadlimit: uploadlimit,
187 closed: if(Keyword.get(instance, :registrations_open), do: "0", else: "1"),
188 private: if(Keyword.get(instance, :public, true), do: "0", else: "1"),
189 vapidPublicKey: vapid_public_key,
190 accountActivationRequired:
191 if(Keyword.get(instance, :account_activation_required, false), do: "1", else: "0"),
192 invitesEnabled: if(Keyword.get(instance, :invites_enabled, false), do: "1", else: "0"),
193 safeDMMentionsEnabled:
194 if(Pleroma.Config.get([:instance, :safe_dm_mentions]), do: "1", else: "0")
197 pleroma_fe = Pleroma.Config.get([:frontend_configurations, :pleroma_fe])
199 managed_config = Keyword.get(instance, :managed_config)
203 data |> Map.put("pleromafe", pleroma_fe)
208 json(conn, %{site: data})
212 def frontend_configurations(conn, _params) do
214 Pleroma.Config.get(:frontend_configurations, %{})
220 def version(conn, _params) do
221 version = Pleroma.Application.named_version()
223 case get_format(conn) do
225 response = "<version>#{version}</version>"
228 |> put_resp_content_type("application/xml")
229 |> send_resp(200, response)
236 def emoji(conn, _params) do
239 |> Enum.map(fn {short_code, path, tags} ->
240 {short_code, %{image_url: path, tags: tags}}
247 def update_notificaton_settings(%{assigns: %{user: user}} = conn, params) do
248 with {:ok, _} <- User.update_notification_settings(user, params) do
249 json(conn, %{status: "success"})
253 def follow_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
254 follow_import(conn, %{"list" => File.read!(listfile.path)})
257 def follow_import(%{assigns: %{user: follower}} = conn, %{"list" => list}) do
258 with lines <- String.split(list, "\n"),
259 followed_identifiers <-
260 Enum.map(lines, fn line ->
261 String.split(line, ",") |> List.first()
263 |> List.delete("Account address") do
264 PleromaJobQueue.enqueue(:background, User, [
270 json(conn, "job started")
274 def blocks_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
275 blocks_import(conn, %{"list" => File.read!(listfile.path)})
278 def blocks_import(%{assigns: %{user: blocker}} = conn, %{"list" => list}) do
279 with blocked_identifiers <- String.split(list) do
280 PleromaJobQueue.enqueue(:background, User, [
286 json(conn, "job started")
290 def change_password(%{assigns: %{user: user}} = conn, params) do
291 case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
294 User.reset_password(user, %{
295 password: params["new_password"],
296 password_confirmation: params["new_password_confirmation"]
298 json(conn, %{status: "success"})
300 {:error, changeset} ->
301 {_, {error, _}} = Enum.at(changeset.errors, 0)
302 json(conn, %{error: "New password #{error}."})
305 json(conn, %{error: "Unable to change password."})
309 json(conn, %{error: msg})
313 def delete_account(%{assigns: %{user: user}} = conn, params) do
314 case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
317 json(conn, %{status: "success"})
320 json(conn, %{error: msg})
324 def disable_account(%{assigns: %{user: user}} = conn, params) do
325 case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
327 User.deactivate_async(user)
328 json(conn, %{status: "success"})
331 json(conn, %{error: msg})
335 def captcha(conn, _params) do
336 json(conn, Pleroma.Captcha.new())
339 def healthcheck(conn, _params) do
340 with true <- Config.get([:instance, :healthcheck]),
341 %{healthy: true} = info <- Healthcheck.system_info() do
344 %{healthy: false} = info ->
345 service_unavailable(conn, info)
348 service_unavailable(conn, %{})
352 defp service_unavailable(conn, info) do
354 |> put_status(:service_unavailable)