Merge branch 'fix/activity-expirations-again' into 'develop'

Fix activity expirations again

See merge request pleroma/pleroma!2866

diff --combined lib/pleroma/web/activity_pub/side_effects.ex
index 5a02f1d69ec6a9a62ba12ba0054c1f6a2839566c,bff7c66290e3086cf93650da5b24c1f6bfa40e50..bcd6fd2fb1d55b10b31f37aa9586aa655dad33bc
--- 1/lib/pleroma/web/activity_pub/side_effects.ex
--- 2/lib/pleroma/web/activity_pub/side_effects.ex
+++ b/lib/pleroma/web/activity_pub/side_effects.ex
@@@ -16,68 -16,16 +16,70 @@@ defmodule Pleroma.Web.ActivityPub.SideE
    alias Pleroma.Repo
    alias Pleroma.User
    alias Pleroma.Web.ActivityPub.ActivityPub
 +  alias Pleroma.Web.ActivityPub.Builder
    alias Pleroma.Web.ActivityPub.Pipeline
    alias Pleroma.Web.ActivityPub.Utils
    alias Pleroma.Web.Push
    alias Pleroma.Web.Streamer
    alias Pleroma.Workers.BackgroundWorker
  
+   require Logger
+ 
    def handle(object, meta \\ [])
  
 +  # Task this handles
 +  # - Follows
 +  # - Sends a notification
 +  def handle(
 +        %{
 +          data: %{
 +            "actor" => actor,
 +            "type" => "Accept",
 +            "object" => follow_activity_id
 +          }
 +        } = object,
 +        meta
 +      ) do
 +    with %Activity{actor: follower_id} = follow_activity <-
 +           Activity.get_by_ap_id(follow_activity_id),
 +         %User{} = followed <- User.get_cached_by_ap_id(actor),
 +         %User{} = follower <- User.get_cached_by_ap_id(follower_id),
 +         {:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"),
 +         {:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do
 +      Notification.update_notification_type(followed, follow_activity)
 +      User.update_follower_count(followed)
 +      User.update_following_count(follower)
 +    end
 +
 +    {:ok, object, meta}
 +  end
 +
 +  # Task this handles
 +  # - Rejects all existing follow activities for this person
 +  # - Updates the follow state
 +  # - Dismisses notification
 +  def handle(
 +        %{
 +          data: %{
 +            "actor" => actor,
 +            "type" => "Reject",
 +            "object" => follow_activity_id
 +          }
 +        } = object,
 +        meta
 +      ) do
 +    with %Activity{actor: follower_id} = follow_activity <-
 +           Activity.get_by_ap_id(follow_activity_id),
 +         %User{} = followed <- User.get_cached_by_ap_id(actor),
 +         %User{} = follower <- User.get_cached_by_ap_id(follower_id),
 +         {:ok, _follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject") do
 +      FollowingRelationship.update(follower, followed, :follow_reject)
 +      Notification.dismiss(follow_activity)
 +    end
 +
 +    {:ok, object, meta}
 +  end
 +
    # Tasks this handle
    # - Follows if possible
    # - Sends a notification
@@@ -98,13 -46,33 +100,13 @@@
           {_, {:ok, _}, _, _} <-
             {:following, User.follow(follower, followed, :follow_pending), follower, followed} do
        if followed.local && !followed.locked do
 -        Utils.update_follow_state_for_all(object, "accept")
 -        FollowingRelationship.update(follower, followed, :follow_accept)
 -        User.update_follower_count(followed)
 -        User.update_following_count(follower)
 -
 -        %{
 -          to: [following_user],
 -          actor: followed,
 -          object: follow_id,
 -          local: true
 -        }
 -        |> ActivityPub.accept()
 +        {:ok, accept_data, _} = Builder.accept(followed, object)
 +        {:ok, _activity, _} = Pipeline.common_pipeline(accept_data, local: true)
        end
      else
 -      {:following, {:error, _}, follower, followed} ->
 -        Utils.update_follow_state_for_all(object, "reject")
 -        FollowingRelationship.update(follower, followed, :follow_reject)
 -
 -        if followed.local do
 -          %{
 -            to: [follower.ap_id],
 -            actor: followed,
 -            object: follow_id,
 -            local: true
 -          }
 -          |> ActivityPub.reject()
 -        end
 +      {:following, {:error, _}, _follower, followed} ->
 +        {:ok, reject_data, _} = Builder.reject(followed, object)
 +        {:ok, _activity, _} = Pipeline.common_pipeline(reject_data, local: true)
  
        _ ->
          nil
@@@ -251,13 -219,15 +253,15 @@@
    # - Stream out the activity
    def handle(%{data: %{"type" => "Delete", "object" => deleted_object}} = object, meta) do
      deleted_object =
-       Object.normalize(deleted_object, false) || User.get_cached_by_ap_id(deleted_object)
+       Object.normalize(deleted_object, false) ||
+         User.get_cached_by_ap_id(deleted_object)
  
      result =
        case deleted_object do
          %Object{} ->
            with {:ok, deleted_object, activity} <- Object.delete(deleted_object),
-                %User{} = user <- User.get_cached_by_ap_id(deleted_object.data["actor"]) do
+                {_, actor} when is_binary(actor) <- {:actor, deleted_object.data["actor"]},
+                %User{} = user <- User.get_cached_by_ap_id(actor) do
              User.remove_pinnned_activity(user, activity)
  
              {:ok, user} = ActivityPub.decrease_note_count_if_public(user, deleted_object)
@@@ -271,6 -241,10 +275,10 @@@
              ActivityPub.stream_out(object)
              ActivityPub.stream_out_participations(deleted_object, user)
              :ok
+           else
+             {:actor, _} ->
+               Logger.error("The object doesn't have an actor: #{inspect(deleted_object)}")
+               :no_object_actor
            end
  
          %User{} ->