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.ActivityPub.ActivityPub
19 alias Pleroma.Web.CommonAPI
20 alias Pleroma.Web.OStatus
21 alias Pleroma.Web.WebFinger
23 def help_test(conn, _params) do
27 def remote_subscribe(conn, %{"nickname" => nick, "profile" => _}) do
28 with %User{} = user <- User.get_cached_by_nickname(nick),
29 avatar = User.avatar_url(user) do
31 |> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
34 render(conn, "subscribe.html", %{
37 error: "Could not find user"
42 def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
43 with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
44 %User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
46 |> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
49 render(conn, "subscribe.html", %{
52 error: "Something went wrong."
57 def remote_follow(%{assigns: %{user: user}} = conn, %{"acct" => acct}) do
58 if is_status?(acct) do
59 {:ok, object} = Pleroma.Object.Fetcher.fetch_object_from_id(acct)
60 %Activity{id: activity_id} = Activity.get_create_by_object_ap_id(object.data["id"])
61 redirect(conn, to: "/notice/#{activity_id}")
63 {err, followee} = OStatus.find_or_make_user(acct)
64 avatar = User.avatar_url(followee)
65 name = followee.nickname
70 |> render("follow.html", %{error: err, acct: acct, avatar: avatar, name: name, id: id})
73 |> render("follow_login.html", %{
84 defp is_status?(acct) do
85 case Pleroma.Object.Fetcher.fetch_and_contain_remote_object_from_id(acct) do
86 {:ok, %{"type" => type}} when type in ["Article", "Note", "Video", "Page", "Question"] ->
94 def do_remote_follow(conn, %{
95 "authorization" => %{"name" => username, "password" => password, "id" => id}
97 followee = User.get_cached_by_id(id)
98 avatar = User.avatar_url(followee)
99 name = followee.nickname
101 with %User{} = user <- User.get_cached_by_nickname(username),
102 true <- AuthenticationPlug.checkpw(password, user.password_hash),
103 %User{} = _followed <- User.get_cached_by_id(id),
104 {:ok, follower} <- User.follow(user, followee),
105 {:ok, _activity} <- ActivityPub.follow(follower, followee) do
107 |> render("followed.html", %{error: false})
109 # Was already following user
110 {:error, "Could not follow user:" <> _rest} ->
111 render(conn, "followed.html", %{error: false})
115 |> render("follow_login.html", %{
116 error: "Wrong username or password",
124 def do_remote_follow(%{assigns: %{user: user}} = conn, %{"user" => %{"id" => id}}) do
125 with %User{} = followee <- User.get_cached_by_id(id),
126 {:ok, follower} <- User.follow(user, followee),
127 {:ok, _activity} <- ActivityPub.follow(follower, followee) do
129 |> render("followed.html", %{error: false})
131 # Was already following user
132 {:error, "Could not follow user:" <> _rest} ->
134 |> render("followed.html", %{error: false})
137 Logger.debug("Remote follow failed with error #{inspect(e)}")
140 |> render("followed.html", %{error: inspect(e)})
144 def notifications_read(%{assigns: %{user: user}} = conn, %{"id" => notification_id}) do
145 with {:ok, _} <- Notification.read_one(user, notification_id) do
146 json(conn, %{status: "success"})
150 |> put_resp_content_type("application/json")
151 |> send_resp(403, Jason.encode!(%{"error" => message}))
155 def config(conn, _params) do
156 instance = Pleroma.Config.get(:instance)
158 case get_format(conn) do
163 <name>#{Keyword.get(instance, :name)}</name>
164 <site>#{Web.base_url()}</site>
165 <textlimit>#{Keyword.get(instance, :limit)}</textlimit>
166 <closed>#{!Keyword.get(instance, :registrations_open)}</closed>
172 |> put_resp_content_type("application/xml")
173 |> send_resp(200, response)
176 vapid_public_key = Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)
179 uploadlimit: to_string(Keyword.get(instance, :upload_limit)),
180 avatarlimit: to_string(Keyword.get(instance, :avatar_upload_limit)),
181 backgroundlimit: to_string(Keyword.get(instance, :background_upload_limit)),
182 bannerlimit: to_string(Keyword.get(instance, :banner_upload_limit))
186 name: Keyword.get(instance, :name),
187 description: Keyword.get(instance, :description),
188 server: Web.base_url(),
189 textlimit: to_string(Keyword.get(instance, :limit)),
190 uploadlimit: uploadlimit,
191 closed: if(Keyword.get(instance, :registrations_open), do: "0", else: "1"),
192 private: if(Keyword.get(instance, :public, true), do: "0", else: "1"),
193 vapidPublicKey: vapid_public_key,
194 accountActivationRequired:
195 if(Keyword.get(instance, :account_activation_required, false), do: "1", else: "0"),
196 invitesEnabled: if(Keyword.get(instance, :invites_enabled, false), do: "1", else: "0"),
197 safeDMMentionsEnabled:
198 if(Pleroma.Config.get([:instance, :safe_dm_mentions]), do: "1", else: "0")
201 pleroma_fe = Pleroma.Config.get([:frontend_configurations, :pleroma_fe])
203 managed_config = Keyword.get(instance, :managed_config)
207 data |> Map.put("pleromafe", pleroma_fe)
212 json(conn, %{site: data})
216 def frontend_configurations(conn, _params) do
218 Pleroma.Config.get(:frontend_configurations, %{})
224 def version(conn, _params) do
225 version = Pleroma.Application.named_version()
227 case get_format(conn) do
229 response = "<version>#{version}</version>"
232 |> put_resp_content_type("application/xml")
233 |> send_resp(200, response)
240 def emoji(conn, _params) do
243 |> Enum.map(fn {short_code, path, tags} ->
244 {short_code, %{image_url: path, tags: tags}}
251 def update_notificaton_settings(%{assigns: %{user: user}} = conn, params) do
252 with {:ok, _} <- User.update_notification_settings(user, params) do
253 json(conn, %{status: "success"})
257 def follow_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
258 follow_import(conn, %{"list" => File.read!(listfile.path)})
261 def follow_import(%{assigns: %{user: follower}} = conn, %{"list" => list}) do
262 with lines <- String.split(list, "\n"),
263 followed_identifiers <-
264 Enum.map(lines, fn line ->
265 String.split(line, ",") |> List.first()
267 |> List.delete("Account address") do
268 PleromaJobQueue.enqueue(:background, User, [
274 json(conn, "job started")
278 def blocks_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
279 blocks_import(conn, %{"list" => File.read!(listfile.path)})
282 def blocks_import(%{assigns: %{user: blocker}} = conn, %{"list" => list}) do
283 with blocked_identifiers <- String.split(list) do
284 PleromaJobQueue.enqueue(:background, User, [
290 json(conn, "job started")
294 def change_password(%{assigns: %{user: user}} = conn, params) do
295 case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
298 User.reset_password(user, %{
299 password: params["new_password"],
300 password_confirmation: params["new_password_confirmation"]
302 json(conn, %{status: "success"})
304 {:error, changeset} ->
305 {_, {error, _}} = Enum.at(changeset.errors, 0)
306 json(conn, %{error: "New password #{error}."})
309 json(conn, %{error: "Unable to change password."})
313 json(conn, %{error: msg})
317 def delete_account(%{assigns: %{user: user}} = conn, params) do
318 case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
321 json(conn, %{status: "success"})
324 json(conn, %{error: msg})
328 def disable_account(%{assigns: %{user: user}} = conn, params) do
329 case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
331 User.deactivate_async(user)
332 json(conn, %{status: "success"})
335 json(conn, %{error: msg})
339 def captcha(conn, _params) do
340 json(conn, Pleroma.Captcha.new())
343 def healthcheck(conn, _params) do
344 with true <- Config.get([:instance, :healthcheck]),
345 %{healthy: true} = info <- Healthcheck.system_info() do
348 %{healthy: false} = info ->
349 service_unavailable(conn, info)
352 service_unavailable(conn, %{})
356 defp service_unavailable(conn, info) do
358 |> put_status(:service_unavailable)