X-Git-Url: http://git.squeep.com/?a=blobdiff_plain;f=lib%2Fpleroma%2Fweb%2Fostatus%2Fostatus.ex;h=cd5493e16ea82b048aa666ea1186045c629213bd;hb=2791ce9a1ff2365ac7256f5e1dc2324dee2f82c9;hp=745539b3e0f68790ceeee8e20c3b73aff26dd3ee;hpb=59770c3f5c9a038dbde6b2e1cd1551a7b8f1672b;p=akkoma

diff --git a/lib/pleroma/web/ostatus/ostatus.ex b/lib/pleroma/web/ostatus/ostatus.ex
index 745539b3e..cd5493e16 100644
--- a/lib/pleroma/web/ostatus/ostatus.ex
+++ b/lib/pleroma/web/ostatus/ostatus.ex
@@ -1,3 +1,7 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
 defmodule Pleroma.Web.OStatus do
   @httpoison Application.get_env(:pleroma, :httpoison)
 
@@ -8,59 +12,93 @@ defmodule Pleroma.Web.OStatus do
   alias Pleroma.{Repo, User, Web, Object, Activity}
   alias Pleroma.Web.ActivityPub.ActivityPub
   alias Pleroma.Web.{WebFinger, Websub}
-  alias Pleroma.Web.OStatus.{FollowHandler, NoteHandler, DeleteHandler}
+  alias Pleroma.Web.OStatus.{FollowHandler, UnfollowHandler, NoteHandler, DeleteHandler}
+  alias Pleroma.Web.ActivityPub.Transmogrifier
+
+  def is_representable?(%Activity{data: data}) do
+    object = Object.normalize(data["object"])
+
+    cond do
+      is_nil(object) ->
+        false
+
+      object.data["type"] == "Note" ->
+        true
+
+      true ->
+        false
+    end
+  end
 
   def feed_path(user) do
     "#{user.ap_id}/feed.atom"
   end
 
   def pubsub_path(user) do
-    "#{Web.base_url}/push/hub/#{user.nickname}"
+    "#{Web.base_url()}/push/hub/#{user.nickname}"
   end
 
   def salmon_path(user) do
     "#{user.ap_id}/salmon"
   end
 
+  def remote_follow_path do
+    "#{Web.base_url()}/ostatus_subscribe?acct={uri}"
+  end
+
   def handle_incoming(xml_string) do
     with doc when doc != :error <- parse_document(xml_string) do
       entries = :xmerl_xpath.string('//entry', doc)
 
-      activities = Enum.map(entries, fn (entry) ->
-        {:xmlObj, :string, object_type} = :xmerl_xpath.string('string(/entry/activity:object-type[1])', entry)
-        {:xmlObj, :string, verb} = :xmerl_xpath.string('string(/entry/activity:verb[1])', entry)
-        Logger.debug("Handling #{verb}")
-
-        try do
-          case verb do
-            'http://activitystrea.ms/schema/1.0/delete' ->
-              with {:ok, activity} <- DeleteHandler.handle_delete(entry, doc), do: activity
-            'http://activitystrea.ms/schema/1.0/follow' ->
-              with {:ok, activity} <- FollowHandler.handle(entry, doc), do: activity
-            'http://activitystrea.ms/schema/1.0/share' ->
-              with {:ok, activity, retweeted_activity} <- handle_share(entry, doc), do: [activity, retweeted_activity]
-            'http://activitystrea.ms/schema/1.0/favorite' ->
-              with {:ok, activity, favorited_activity} <- handle_favorite(entry, doc), do: [activity, favorited_activity]
-            _ ->
-              case object_type do
-                'http://activitystrea.ms/schema/1.0/note' ->
-                  with {:ok, activity} <- NoteHandler.handle_note(entry, doc), do: activity
-                'http://activitystrea.ms/schema/1.0/comment' ->
-                  with {:ok, activity} <- NoteHandler.handle_note(entry, doc), do: activity
-                _ ->
-                  Logger.error("Couldn't parse incoming document")
-                  nil
-              end
+      activities =
+        Enum.map(entries, fn entry ->
+          {:xmlObj, :string, object_type} =
+            :xmerl_xpath.string('string(/entry/activity:object-type[1])', entry)
+
+          {:xmlObj, :string, verb} = :xmerl_xpath.string('string(/entry/activity:verb[1])', entry)
+          Logger.debug("Handling #{verb}")
+
+          try do
+            case verb do
+              'http://activitystrea.ms/schema/1.0/delete' ->
+                with {:ok, activity} <- DeleteHandler.handle_delete(entry, doc), do: activity
+
+              'http://activitystrea.ms/schema/1.0/follow' ->
+                with {:ok, activity} <- FollowHandler.handle(entry, doc), do: activity
+
+              'http://activitystrea.ms/schema/1.0/unfollow' ->
+                with {:ok, activity} <- UnfollowHandler.handle(entry, doc), do: activity
+
+              'http://activitystrea.ms/schema/1.0/share' ->
+                with {:ok, activity, retweeted_activity} <- handle_share(entry, doc),
+                     do: [activity, retweeted_activity]
+
+              'http://activitystrea.ms/schema/1.0/favorite' ->
+                with {:ok, activity, favorited_activity} <- handle_favorite(entry, doc),
+                     do: [activity, favorited_activity]
+
+              _ ->
+                case object_type do
+                  'http://activitystrea.ms/schema/1.0/note' ->
+                    with {:ok, activity} <- NoteHandler.handle_note(entry, doc), do: activity
+
+                  'http://activitystrea.ms/schema/1.0/comment' ->
+                    with {:ok, activity} <- NoteHandler.handle_note(entry, doc), do: activity
+
+                  _ ->
+                    Logger.error("Couldn't parse incoming document")
+                    nil
+                end
+            end
+          rescue
+            e ->
+              Logger.error("Error occured while handling activity")
+              Logger.error(xml_string)
+              Logger.error(inspect(e))
+              nil
           end
-        rescue
-          e ->
-            Logger.error("Error occured while handling activity")
-            Logger.error(xml_string)
-          Logger.error(inspect(e))
-          nil
-        end
-      end)
-      |> Enum.filter(&(&1))
+        end)
+        |> Enum.filter(& &1)
 
       {:ok, activities}
     else
@@ -70,7 +108,7 @@ defmodule Pleroma.Web.OStatus do
 
   def make_share(entry, doc, retweeted_activity) do
     with {:ok, actor} <- find_make_or_update_user(doc),
-         %Object{} = object <- Object.get_by_ap_id(retweeted_activity.data["object"]["id"]),
+         %Object{} = object <- Object.normalize(retweeted_activity.data["object"]),
          id when not is_nil(id) <- string_from_xpath("/entry/id", entry),
          {:ok, activity, _object} = ActivityPub.announce(actor, object, id, false) do
       {:ok, activity}
@@ -88,7 +126,7 @@ defmodule Pleroma.Web.OStatus do
 
   def make_favorite(entry, doc, favorited_activity) do
     with {:ok, actor} <- find_make_or_update_user(doc),
-         %Object{} = object <- Object.get_by_ap_id(favorited_activity.data["object"]["id"]),
+         %Object{} = object <- Object.normalize(favorited_activity.data["object"]),
          id when not is_nil(id) <- string_from_xpath("/entry/id", entry),
          {:ok, activity, _object} = ActivityPub.like(actor, object, id, false) do
       {:ok, activity}
@@ -108,15 +146,20 @@ defmodule Pleroma.Web.OStatus do
 
   def get_or_try_fetching(entry) do
     Logger.debug("Trying to get entry from db")
+
     with id when not is_nil(id) <- string_from_xpath("//activity:object[1]/id", entry),
          %Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
       {:ok, activity}
-    else _ ->
+    else
+      _ ->
         Logger.debug("Couldn't get, will try to fetch")
-        with href when not is_nil(href) <- string_from_xpath("//activity:object[1]/link[@type=\"text/html\"]/@href", entry),
+
+        with href when not is_nil(href) <-
+               string_from_xpath("//activity:object[1]/link[@type=\"text/html\"]/@href", entry),
              {:ok, [favorited_activity]} <- fetch_activity_from_url(href) do
           {:ok, favorited_activity}
-        else e -> Logger.debug("Couldn't find href: #{inspect(e)}")
+        else
+          e -> Logger.debug("Couldn't find href: #{inspect(e)}")
         end
     end
   end
@@ -132,20 +175,22 @@ defmodule Pleroma.Web.OStatus do
 
   def get_attachments(entry) do
     :xmerl_xpath.string('/entry/link[@rel="enclosure"]', entry)
-    |> Enum.map(fn (enclosure) ->
+    |> Enum.map(fn enclosure ->
       with href when not is_nil(href) <- string_from_xpath("/link/@href", enclosure),
            type when not is_nil(type) <- string_from_xpath("/link/@type", enclosure) do
         %{
           "type" => "Attachment",
-          "url" => [%{
-                       "type" => "Link",
-                       "mediaType" => type,
-                       "href" => href
-                    }]
+          "url" => [
+            %{
+              "type" => "Link",
+              "mediaType" => type,
+              "href" => href
+            }
+          ]
         }
       end
     end)
-    |> Enum.filter(&(&1))
+    |> Enum.filter(& &1)
   end
 
   @doc """
@@ -159,52 +204,63 @@ defmodule Pleroma.Web.OStatus do
     Get the cw that mastodon uses.
   """
   def get_cw(entry) do
-    with scope when not is_nil(scope) <- string_from_xpath("//mastodon:scope", entry),
-         cw when not is_nil(cw) <- string_from_xpath("/*/summary", entry) do
+    with cw when not is_nil(cw) <- string_from_xpath("/*/summary", entry) do
       cw
-    else _e -> nil
+    else
+      _e -> nil
     end
   end
 
   def get_tags(entry) do
     :xmerl_xpath.string('//category', entry)
-    |> Enum.map(fn (category) -> string_from_xpath("/category/@term", category) end)
-    |> Enum.filter(&(&1))
+    |> Enum.map(fn category -> string_from_xpath("/category/@term", category) end)
+    |> Enum.filter(& &1)
     |> Enum.map(&String.downcase/1)
   end
 
   def maybe_update(doc, user) do
+    if "true" == string_from_xpath("//author[1]/ap_enabled", doc) do
+      Transmogrifier.upgrade_user_from_ap_id(user.ap_id)
+    else
+      maybe_update_ostatus(doc, user)
+    end
+  end
+
+  def maybe_update_ostatus(doc, user) do
     old_data = %{
       avatar: user.avatar,
       bio: user.bio,
-      name: user.name,
-      info: user.info
+      name: user.name
     }
 
     with false <- user.local,
          avatar <- make_avatar_object(doc),
          bio <- string_from_xpath("//author[1]/summary", doc),
          name <- string_from_xpath("//author[1]/poco:displayName", doc),
-         info <- Map.put(user.info, "banner", make_avatar_object(doc, "header") || user.info["banner"]),
-         new_data <- %{avatar: avatar || old_data.avatar, name: name || old_data.name, bio: bio || old_data.bio, info: info || old_data.info},
+         new_data <- %{
+           avatar: avatar || old_data.avatar,
+           name: name || old_data.name,
+           bio: bio || old_data.bio
+         },
          false <- new_data == old_data do
       change = Ecto.Changeset.change(user, new_data)
-      Repo.update(change)
-    else _ ->
-      {:ok, user}
+      User.update_and_set_cache(change)
+    else
+      _ ->
+        {:ok, user}
     end
   end
 
   def find_make_or_update_user(doc) do
     uri = string_from_xpath("//author/uri[1]", doc)
+
     with {:ok, user} <- find_or_make_user(uri) do
       maybe_update(doc, user)
     end
   end
 
   def find_or_make_user(uri) do
-    query = from user in User,
-      where: user.ap_id == ^uri
+    query = from(user in User, where: user.ap_id == ^uri)
 
     user = Repo.one(query)
 
@@ -215,11 +271,6 @@ defmodule Pleroma.Web.OStatus do
     end
   end
 
-  def insert_or_update_user(data) do
-    cs = User.remote_user_creation(data)
-    Repo.insert(cs, on_conflict: :replace_all, conflict_target: :nickname)
-  end
-
   def make_user(uri, update \\ false) do
     with {:ok, info} <- gather_user_info(uri) do
       data = %{
@@ -230,10 +281,12 @@ defmodule Pleroma.Web.OStatus do
         avatar: info["avatar"],
         bio: info["bio"]
       }
+
       with false <- update,
            %User{} = user <- User.get_by_ap_id(data.ap_id) do
         {:ok, user}
-      else _e -> insert_or_update_user(data)
+      else
+        _e -> User.insert_or_update_user(data)
       end
     end
   end
@@ -246,12 +299,13 @@ defmodule Pleroma.Web.OStatus do
     if href do
       %{
         "type" => "Image",
-        "url" =>
-          [%{
-              "type" => "Link",
-              "mediaType" => type,
-              "href" => href
-           }]
+        "url" => [
+          %{
+            "type" => "Link",
+            "mediaType" => type,
+            "href" => href
+          }
+        ]
       }
     else
       nil
@@ -262,9 +316,10 @@ defmodule Pleroma.Web.OStatus do
     with {:ok, webfinger_data} <- WebFinger.finger(username),
          {:ok, feed_data} <- Websub.gather_feed_data(webfinger_data["topic"]) do
       {:ok, Map.merge(webfinger_data, feed_data) |> Map.put("fqn", username)}
-    else e ->
-      Logger.debug(fn -> "Couldn't gather info for #{username}" end)
-      {:error, e}
+    else
+      e ->
+        Logger.debug(fn -> "Couldn't gather info for #{username}" end)
+        {:error, e}
     end
   end
 
@@ -278,48 +333,60 @@ defmodule Pleroma.Web.OStatus do
       Regex.match?(@mastodon_regex, body) ->
         [[_, match]] = Regex.scan(@mastodon_regex, body)
         {:ok, match}
+
       Regex.match?(@gs_regex, body) ->
         [[_, match]] = Regex.scan(@gs_regex, body)
         {:ok, match}
+
       Regex.match?(@gs_classic_regex, body) ->
         [[_, match]] = Regex.scan(@gs_classic_regex, body)
         {:ok, match}
+
       true ->
-        Logger.debug(fn -> "Couldn't find atom link in #{inspect(body)}" end)
-        {:error, "Couldn't find the atom link"}
+        Logger.debug(fn -> "Couldn't find Atom link in #{inspect(body)}" end)
+        {:error, "Couldn't find the Atom link"}
     end
   end
 
   def fetch_activity_from_atom_url(url) do
-    with {:ok, %{body: body, status_code: code}} when code in 200..299 <- @httpoison.get(url, [Accept: "application/atom+xml"], follow_redirect: true, timeout: 10000, recv_timeout: 20000) do
+    with true <- String.starts_with?(url, "http"),
+         {:ok, %{body: body, status: code}} when code in 200..299 <-
+           @httpoison.get(
+             url,
+             [{:Accept, "application/atom+xml"}]
+           ) do
       Logger.debug("Got document from #{url}, handling...")
       handle_incoming(body)
-    else e -> Logger.debug("Couldn't get #{url}: #{inspect(e)}")
+    else
+      e ->
+        Logger.debug("Couldn't get #{url}: #{inspect(e)}")
+        e
     end
   end
 
   def fetch_activity_from_html_url(url) do
     Logger.debug("Trying to fetch #{url}")
-    with {:ok, %{body: body}} <- @httpoison.get(url, [], follow_redirect: true, timeout: 10000, recv_timeout: 20000),
+
+    with true <- String.starts_with?(url, "http"),
+         {:ok, %{body: body}} <- @httpoison.get(url, []),
          {:ok, atom_url} <- get_atom_url(body) do
-        fetch_activity_from_atom_url(atom_url)
-    else e -> Logger.debug("Couldn't get #{url}: #{inspect(e)}")
+      fetch_activity_from_atom_url(atom_url)
+    else
+      e ->
+        Logger.debug("Couldn't get #{url}: #{inspect(e)}")
+        e
     end
   end
 
   def fetch_activity_from_url(url) do
-    try do
-      with {:ok, activities} when length(activities) > 0 <- fetch_activity_from_atom_url(url) do
-        {:ok, activities}
-      else
-        _e -> with {:ok, activities} <- fetch_activity_from_html_url(url) do
-                {:ok, activities}
-              end
-      end
-    rescue
-      e ->
-        Logger.debug("Couldn't get #{url}: #{inspect(e)}")
-        {:error, "Couldn't get #{url}: #{inspect(e)}"}
+    with {:ok, [_ | _] = activities} <- fetch_activity_from_atom_url(url) do
+      {:ok, activities}
+    else
+      _e -> fetch_activity_from_html_url(url)
     end
+  rescue
+    e ->
+      Logger.debug("Couldn't get #{url}: #{inspect(e)}")
+      {:error, "Couldn't get #{url}: #{inspect(e)}"}
   end
 end