git.squeep.com Git - akkoma/blob - lib/pleroma/web/twitter_api/controllers/util_controller.ex

   1 defmodule Pleroma.Web.TwitterAPI.UtilController do
   2   use Pleroma.Web, :controller
   3   require Logger
   4   alias Pleroma.Web
   5   alias Pleroma.Web.OStatus
   6   alias Comeonin.Pbkdf2
   7   alias Pleroma.Formatter
   8   alias Pleroma.Web.ActivityPub.ActivityPub
   9   alias Pleroma.{Repo, PasswordResetToken, User}
  10
  11   def show_password_reset(conn, %{"token" => token}) do
  12     with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}),
  13       %User{} = user <- Repo.get(User, token.user_id) do
  14       render conn, "password_reset.html", %{
  15         token: token,
  16         user: user
  17       }
  18     else
  19       _e -> render conn, "invalid_token.html"
  20     end
  21   end
  22
  23   def password_reset(conn, %{"data" => data}) do
  24     with {:ok, _} <- PasswordResetToken.reset_password(data["token"], data) do
  25       render conn, "password_reset_success.html"
  26     else
  27       _e -> render conn, "password_reset_failed.html"
  28     end
  29   end
  30
  31   def help_test(conn, _params) do
  32     json(conn, "ok")
  33   end
  34
  35   def remote_follow(%{assigns: %{user: user}} = conn, %{"acct" => acct}) do
  36     {err, followee} = OStatus.find_or_make_user(acct)
  37     avatar = User.avatar_url(followee)
  38     name = followee.nickname
  39     id = followee.id
  40
  41     if !!user do
  42       conn
  43       |> render("follow.html", %{error: err, acct: acct, avatar: avatar, name: name, id: id})
  44     else
  45       conn
  46       |> render("follow_login.html", %{error: false, acct: acct, avatar: avatar, name: name, id: id})
  47     end
  48   end
  49
  50   def do_remote_follow(conn, %{"authorization" => %{"name" => username, "password" => password, "id" => id}}) do
  51     followee = Repo.get(User, id)
  52     avatar = User.avatar_url(followee)
  53     name = followee.nickname
  54     with %User{} = user <- User.get_cached_by_nickname(username),
  55          true <- Pbkdf2.checkpw(password, user.password_hash),
  56            %User{} = followed <- Repo.get(User, id),
  57          {:ok, follower} <- User.follow(user, followee),
  58          {:ok, _activity} <- ActivityPub.follow(follower, followee) do
  59       conn
  60       |> render("followed.html", %{error: false})
  61     else
  62       _e ->
  63         conn
  64         |> render("follow_login.html", %{error: "Wrong username or password", id: id, name: name, avatar: avatar})
  65     end
  66   end
  67   def do_remote_follow(%{assigns: %{user: user}} = conn, %{"user" => %{"id" => id}}) do
  68     with %User{} = followee <- Repo.get(User, id),
  69          {:ok, follower} <- User.follow(user, followee),
  70          {:ok, _activity} <- ActivityPub.follow(follower, followee) do
  71       conn
  72       |> render("followed.html", %{error: false})
  73     else
  74       e ->
  75         Logger.debug("Remote follow failed with error #{inspect e}")
  76       conn
  77       |> render("followed.html", %{error: inspect(e)})
  78     end
  79   end
  80
  81   @instance Application.get_env(:pleroma, :instance)
  82   def config(conn, _params) do
  83     case get_format(conn) do
  84       "xml" ->
  85         response = """
  86         <config>
  87           <site>
  88             <name>#{Keyword.get(@instance, :name)}</name>
  89             <site>#{Web.base_url}</site>
  90             <textlimit>#{Keyword.get(@instance, :limit)}</textlimit>
  91             <closed>#{!Keyword.get(@instance, :registrations_open)}</closed>
  92           </site>
  93         </config>
  94         """
  95         conn
  96         |> put_resp_content_type("application/xml")
  97         |> send_resp(200, response)
  98       _ ->
  99         json(conn, %{
 100               site: %{
 101                 name: Keyword.get(@instance, :name),
 102                 server: Web.base_url,
 103                 textlimit: Keyword.get(@instance, :limit),
 104                 closed: if(Keyword.get(@instance, :registrations_open), do: "0", else: "1")
 105               }
 106              })
 107     end
 108   end
 109
 110   def version(conn, _params) do
 111     version = Keyword.get(@instance, :version)
 112     case get_format(conn) do
 113       "xml" ->
 114         response = "<version>#{version}</version>"
 115         conn
 116         |> put_resp_content_type("application/xml")
 117         |> send_resp(200, response)
 118       _ -> json(conn, version)
 119     end
 120   end
 121
 122   def emoji(conn, _params) do
 123     json conn, Enum.into(Formatter.get_custom_emoji(), %{})
 124   end
 125
 126   def follow_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
 127     follow_import(conn, %{"list" => File.read!(listfile.path)})
 128   end
 129   def follow_import(%{assigns: %{user: user}} = conn, %{"list" => list}) do
 130     Task.start(fn ->
 131     String.split(list)
 132     |> Enum.map(fn nick ->
 133         with %User{} = follower <- User.get_cached_by_ap_id(user.ap_id),
 134         %User{} = followed <- User.get_or_fetch_by_nickname(nick),
 135         {:ok, follower} <- User.follow(follower, followed) do
 136           ActivityPub.follow(follower, followed)
 137         else
 138           _e -> Logger.debug "follow_import: following #{nick} failed"
 139         end
 140       end)
 141     end)
 142
 143     json conn, "job started"
 144   end
 145 end