X-Git-Url: http://git.squeep.com/?a=blobdiff_plain;f=lib%2Fpleroma%2Fweb%2Ftwitter_api%2Ftwitter_api_controller.ex;h=56690cd6bb33a461b7a0debf244ccd2b0973411d;hb=1555c66650967c5023b2a4f7a44a683d803091c6;hp=4a1622cc80b540601520f1b32350941e492f6d36;hpb=36448d6483c7f53266052e72bd39b04558478410;p=akkoma

diff --git a/lib/pleroma/web/twitter_api/twitter_api_controller.ex b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
index 4a1622cc8..56690cd6b 100644
--- a/lib/pleroma/web/twitter_api/twitter_api_controller.ex
+++ b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
@@ -1,27 +1,28 @@
 defmodule Pleroma.Web.TwitterAPI.Controller do
   use Pleroma.Web, :controller
-  alias Pleroma.Web.TwitterAPI.TwitterAPI
-  alias Pleroma.Web.TwitterAPI.Representers.{UserRepresenter, ActivityRepresenter}
-  alias Pleroma.{Web, Repo, Activity}
+  alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView, ActivityView, NotificationView}
+  alias Pleroma.Web.CommonAPI
+  alias Pleroma.{Repo, Activity, User, Notification}
   alias Pleroma.Web.ActivityPub.ActivityPub
   alias Ecto.Changeset
 
-  def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
-    response = user |> UserRepresenter.to_json(%{for: user})
+  require Logger
 
-    conn
-    |> json_reply(200, response)
+  action_fallback(:errors)
+
+  def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
+    token = Phoenix.Token.sign(conn, "user socket", user.id)
+    render(conn, UserView, "show.json", %{user: user, token: token})
   end
 
-  def status_update(%{assigns: %{user: user}} = conn, %{"status" => status_text} = status_data) do
-    l = status_text |> String.trim |> String.length
-    if l > 0 && l < 5000 do
-      media_ids = extract_media_ids(status_data)
-      {:ok, activity} = TwitterAPI.create_status(user, Map.put(status_data, "media_ids",  media_ids))
+  def status_update(%{assigns: %{user: user}} = conn, %{"status" => _} = status_data) do
+    with media_ids <- extract_media_ids(status_data),
+         {:ok, activity} <-
+           TwitterAPI.create_status(user, Map.put(status_data, "media_ids", media_ids)) do
       conn
-      |> json_reply(200, ActivityRepresenter.to_json(activity, %{user: user}))
+      |> json(ActivityView.render("activity.json", activity: activity, for: user))
     else
-      empty_status_reply(conn)
+      _ -> empty_status_reply(conn)
     end
   end
 
@@ -36,185 +37,351 @@ defmodule Pleroma.Web.TwitterAPI.Controller do
   defp extract_media_ids(status_data) do
     with media_ids when not is_nil(media_ids) <- status_data["media_ids"],
          split_ids <- String.split(media_ids, ","),
-         clean_ids <- Enum.reject(split_ids, fn (id) -> String.length(id) == 0 end)
-      do
-        clean_ids
-      else _e -> []
+         clean_ids <- Enum.reject(split_ids, fn id -> String.length(id) == 0 end) do
+      clean_ids
+    else
+      _e -> []
     end
   end
 
   def public_and_external_timeline(%{assigns: %{user: user}} = conn, params) do
-    statuses = TwitterAPI.fetch_public_and_external_statuses(user, params)
-    {:ok, json} = Poison.encode(statuses)
+    params =
+      params
+      |> Map.put("type", ["Create", "Announce"])
+      |> Map.put("blocking_user", user)
+
+    activities = ActivityPub.fetch_public_activities(params)
 
     conn
-    |> json_reply(200, json)
+    |> render(ActivityView, "index.json", %{activities: activities, for: user})
   end
 
   def public_timeline(%{assigns: %{user: user}} = conn, params) do
-    statuses = TwitterAPI.fetch_public_statuses(user, params)
-    {:ok, json} = Poison.encode(statuses)
+    params =
+      params
+      |> Map.put("type", ["Create", "Announce"])
+      |> Map.put("local_only", true)
+      |> Map.put("blocking_user", user)
+
+    activities = ActivityPub.fetch_public_activities(params)
 
     conn
-    |> json_reply(200, json)
+    |> render(ActivityView, "index.json", %{activities: activities, for: user})
   end
 
   def friends_timeline(%{assigns: %{user: user}} = conn, params) do
-    statuses = TwitterAPI.fetch_friend_statuses(user, params)
-    {:ok, json} = Poison.encode(statuses)
+    params =
+      params
+      |> Map.put("type", ["Create", "Announce", "Follow", "Like"])
+      |> Map.put("blocking_user", user)
+      |> Map.put("user", user)
+
+    activities = ActivityPub.fetch_activities([user.ap_id | user.following], params)
 
     conn
-    |> json_reply(200, json)
+    |> render(ActivityView, "index.json", %{activities: activities, for: user})
+  end
+
+  def show_user(conn, params) do
+    with {:ok, shown} <- TwitterAPI.get_user(params) do
+      if user = conn.assigns.user do
+        render(conn, UserView, "show.json", %{user: shown, for: user})
+      else
+        render(conn, UserView, "show.json", %{user: shown})
+      end
+    else
+      {:error, msg} ->
+        bad_request_reply(conn, msg)
+    end
   end
 
   def user_timeline(%{assigns: %{user: user}} = conn, params) do
     case TwitterAPI.get_user(user, params) do
       {:ok, target_user} ->
-        params = Map.merge(params, %{"actor_id" => target_user.ap_id})
-        statuses  = TwitterAPI.fetch_user_statuses(user, params)
+        activities = ActivityPub.fetch_user_activities(target_user, user, params)
+
         conn
-        |> json_reply(200, statuses |> Poison.encode!)
+        |> render(ActivityView, "index.json", %{activities: activities, for: user})
+
       {:error, msg} ->
         bad_request_reply(conn, msg)
     end
   end
 
   def mentions_timeline(%{assigns: %{user: user}} = conn, params) do
-    statuses = TwitterAPI.fetch_mentions(user, params)
-    {:ok, json} = Poison.encode(statuses)
+    params =
+      params
+      |> Map.put("type", ["Create", "Announce", "Follow", "Like"])
+      |> Map.put("blocking_user", user)
+
+    activities = ActivityPub.fetch_activities([user.ap_id], params)
+
+    conn
+    |> render(ActivityView, "index.json", %{activities: activities, for: user})
+  end
+
+  def notifications(%{assigns: %{user: user}} = conn, params) do
+    notifications = Notification.for_user(user, params)
 
     conn
-    |> json_reply(200, json)
+    |> render(NotificationView, "notification.json", %{notifications: notifications, for: user})
   end
 
   def follow(%{assigns: %{user: user}} = conn, params) do
     case TwitterAPI.follow(user, params) do
       {:ok, user, followed, _activity} ->
-        response = followed |> UserRepresenter.to_json(%{for: user})
-        conn
-        |> json_reply(200, response)
-      {:error, msg} -> forbidden_json_reply(conn, msg)
+        render(conn, UserView, "show.json", %{user: followed, for: user})
+
+      {:error, msg} ->
+        forbidden_json_reply(conn, msg)
+    end
+  end
+
+  def block(%{assigns: %{user: user}} = conn, params) do
+    case TwitterAPI.block(user, params) do
+      {:ok, user, blocked} ->
+        render(conn, UserView, "show.json", %{user: blocked, for: user})
+
+      {:error, msg} ->
+        forbidden_json_reply(conn, msg)
+    end
+  end
+
+  def unblock(%{assigns: %{user: user}} = conn, params) do
+    case TwitterAPI.unblock(user, params) do
+      {:ok, user, blocked} ->
+        render(conn, UserView, "show.json", %{user: blocked, for: user})
+
+      {:error, msg} ->
+        forbidden_json_reply(conn, msg)
+    end
+  end
+
+  def delete_post(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+    with {:ok, activity} <- TwitterAPI.delete(user, id) do
+      render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
     end
   end
 
   def unfollow(%{assigns: %{user: user}} = conn, params) do
     case TwitterAPI.unfollow(user, params) do
       {:ok, user, unfollowed} ->
-        response = unfollowed |> UserRepresenter.to_json(%{for: user})
-        conn
-        |> json_reply(200, response)
-      {:error, msg} -> forbidden_json_reply(conn, msg)
+        render(conn, UserView, "show.json", %{user: unfollowed, for: user})
+
+      {:error, msg} ->
+        forbidden_json_reply(conn, msg)
     end
   end
 
   def fetch_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
-    response = Poison.encode!(TwitterAPI.fetch_status(user, id))
-
-    conn
-    |> json_reply(200, response)
+    with %Activity{} = activity <- Repo.get(Activity, id),
+         true <- ActivityPub.visible_for_user?(activity, user) do
+      render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
+    end
   end
 
   def fetch_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
     id = String.to_integer(id)
-    response = Poison.encode!(TwitterAPI.fetch_conversation(user, id))
 
-    conn
-    |> json_reply(200, response)
+    with context when is_binary(context) <- TwitterAPI.conversation_id_to_context(id),
+         activities <-
+           ActivityPub.fetch_activities_for_context(context, %{
+             "blocking_user" => user,
+             "user" => user
+           }) do
+      conn
+      |> render(ActivityView, "index.json", %{activities: activities, for: user})
+    end
   end
 
   def upload(conn, %{"media" => media}) do
     response = TwitterAPI.upload(media)
+
     conn
     |> put_resp_content_type("application/atom+xml")
     |> send_resp(200, response)
   end
 
-  def help_test(conn, _params) do
-    conn |> json_reply(200, Poison.encode!("ok"))
-  end
-
   def upload_json(conn, %{"media" => media}) do
     response = TwitterAPI.upload(media, "json")
+
     conn
     |> json_reply(200, response)
   end
 
-  def config(conn, _params) do
-    response = %{
-      site: %{
-        name: Web.base_url,
-        server: Web.base_url,
-        textlimit: -1
-      }
-    }
-    |> Poison.encode!
+  def get_by_id_or_ap_id(id) do
+    activity = Repo.get(Activity, id) || Activity.get_create_activity_by_object_ap_id(id)
 
-    conn
-    |> json_reply(200, response)
+    if activity.data["type"] == "Create" do
+      activity
+    else
+      Activity.get_create_activity_by_object_ap_id(activity.data["object"])
+    end
   end
 
   def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
-    activity = Repo.get(Activity, id)
-    {:ok, status} = TwitterAPI.favorite(user, activity)
-    response = Poison.encode!(status)
-
-    conn
-    |> json_reply(200, response)
+    with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
+         {:ok, activity} <- TwitterAPI.fav(user, id) do
+      render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
+    end
   end
 
   def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
-    activity = Repo.get(Activity, id)
-    {:ok, status} = TwitterAPI.unfavorite(user, activity)
-    response = Poison.encode!(status)
-
-    conn
-    |> json_reply(200, response)
+    with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
+         {:ok, activity} <- TwitterAPI.unfav(user, id) do
+      render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
+    end
   end
 
   def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
-    activity = Repo.get(Activity, id)
-    if activity.data["actor"] == user.ap_id do
-      bad_request_reply(conn, "You cannot repeat your own notice.")
-    else
-      {:ok, status} = TwitterAPI.retweet(user, activity)
-      response = Poison.encode!(status)
-
-      conn
+    with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
+         {:ok, activity} <- TwitterAPI.repeat(user, id) do
+      render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
+    end
+  end
 
-      |> json_reply(200, response)
+  def unretweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+    with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
+         {:ok, activity} <- TwitterAPI.unrepeat(user, id) do
+      render(conn, ActivityView, "activity.json", %{activity: activity, for: user})
     end
   end
 
   def register(conn, params) do
     with {:ok, user} <- TwitterAPI.register_user(params) do
-      conn
-      |> json_reply(200, Poison.encode!(user))
+      render(conn, UserView, "show.json", %{user: user})
     else
       {:error, errors} ->
-      conn
-      |> json_reply(400, Poison.encode!(errors))
+        conn
+        |> json_reply(400, Jason.encode!(errors))
     end
   end
 
   def update_avatar(%{assigns: %{user: user}} = conn, params) do
     {:ok, object} = ActivityPub.upload(params)
     change = Changeset.change(user, %{avatar: object.data})
-    {:ok, user} = Repo.update(change)
+    {:ok, user} = User.update_and_set_cache(change)
+    CommonAPI.update(user)
 
-    response = Poison.encode!(UserRepresenter.to_map(user, %{for: user}))
+    render(conn, UserView, "show.json", %{user: user, for: user})
+  end
 
-    conn
-    |> json_reply(200, response)
+  def update_banner(%{assigns: %{user: user}} = conn, params) do
+    with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}),
+         new_info <- Map.put(user.info, "banner", object.data),
+         change <- User.info_changeset(user, %{info: new_info}),
+         {:ok, user} <- User.update_and_set_cache(change) do
+      CommonAPI.update(user)
+      %{"url" => [%{"href" => href} | _]} = object.data
+      response = %{url: href} |> Jason.encode!()
+
+      conn
+      |> json_reply(200, response)
+    end
+  end
+
+  def update_background(%{assigns: %{user: user}} = conn, params) do
+    with {:ok, object} <- ActivityPub.upload(params),
+         new_info <- Map.put(user.info, "background", object.data),
+         change <- User.info_changeset(user, %{info: new_info}),
+         {:ok, _user} <- User.update_and_set_cache(change) do
+      %{"url" => [%{"href" => href} | _]} = object.data
+      response = %{url: href} |> Jason.encode!()
+
+      conn
+      |> json_reply(200, response)
+    end
   end
 
   def external_profile(%{assigns: %{user: current_user}} = conn, %{"profileurl" => uri}) do
     with {:ok, user_map} <- TwitterAPI.get_external_profile(current_user, uri),
-         response <- Poison.encode!(user_map) do
+         response <- Jason.encode!(user_map) do
       conn
       |> json_reply(200, response)
+    else
+      _e ->
+        conn
+        |> put_status(404)
+        |> json(%{error: "Can't find user"})
     end
   end
 
+  def update_most_recent_notification(%{assigns: %{user: user}} = conn, %{"id" => id}) do
+    with id when is_number(id) <- String.to_integer(id),
+         info <- user.info,
+         mrn <- max(id, user.info["most_recent_notification"] || 0),
+         updated_info <- Map.put(info, "most_recent_notification", mrn),
+         changeset <- User.info_changeset(user, %{info: updated_info}),
+         {:ok, _user} <- User.update_and_set_cache(changeset) do
+      conn
+      |> json_reply(200, Jason.encode!(mrn))
+    else
+      _e -> bad_request_reply(conn, "Can't update.")
+    end
+  end
+
+  def followers(conn, params) do
+    with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
+         {:ok, followers} <- User.get_followers(user) do
+      render(conn, UserView, "index.json", %{users: followers, for: conn.assigns[:user]})
+    else
+      _e -> bad_request_reply(conn, "Can't get followers")
+    end
+  end
+
+  def friends(conn, params) do
+    with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
+         {:ok, friends} <- User.get_friends(user) do
+      render(conn, UserView, "index.json", %{users: friends, for: conn.assigns[:user]})
+    else
+      _e -> bad_request_reply(conn, "Can't get friends")
+    end
+  end
+
+  def friends_ids(%{assigns: %{user: user}} = conn, _params) do
+    with {:ok, friends} <- User.get_friends(user) do
+      ids =
+        friends
+        |> Enum.map(fn x -> x.id end)
+        |> Jason.encode!()
+
+      json(conn, ids)
+    else
+      _e -> bad_request_reply(conn, "Can't get friends")
+    end
+  end
+
+  def empty_array(conn, _params) do
+    json(conn, Jason.encode!([]))
+  end
+
+  def update_profile(%{assigns: %{user: user}} = conn, params) do
+    params =
+      if bio = params["description"] do
+        bio_brs = Regex.replace(~r/\r?\n/, bio, "<br>")
+        Map.put(params, "bio", bio_brs)
+      else
+        params
+      end
+
+    with changeset <- User.update_changeset(user, params),
+         {:ok, user} <- User.update_and_set_cache(changeset) do
+      CommonAPI.update(user)
+      render(conn, UserView, "user.json", %{user: user, for: user})
+    else
+      error ->
+        Logger.debug("Can't update user: #{inspect(error)}")
+        bad_request_reply(conn, "Can't update user")
+    end
+  end
+
+  def search(%{assigns: %{user: user}} = conn, %{"q" => _query} = params) do
+    activities = TwitterAPI.search(user, params)
+
+    conn
+    |> render(ActivityView, "index.json", %{activities: activities, for: user})
+  end
+
   defp bad_request_reply(conn, error_message) do
     json = error_json(conn, error_message)
     json_reply(conn, 400, json)
@@ -232,6 +399,18 @@ defmodule Pleroma.Web.TwitterAPI.Controller do
   end
 
   defp error_json(conn, error_message) do
-    %{"error" => error_message, "request" => conn.request_path} |> Poison.encode!
+    %{"error" => error_message, "request" => conn.request_path} |> Jason.encode!()
+  end
+
+  def errors(conn, {:param_cast, _}) do
+    conn
+    |> put_status(400)
+    |> json("Invalid parameters")
+  end
+
+  def errors(conn, _) do
+    conn
+    |> put_status(500)
+    |> json("Something went wrong")
   end
 end