Merge branch 'develop' of git.pleroma.social:pleroma/pleroma into remake-remodel-dms
authorlain <lain@soykaf.club>
Thu, 7 May 2020 13:05:40 +0000 (15:05 +0200)
committerlain <lain@soykaf.club>
Thu, 7 May 2020 13:05:40 +0000 (15:05 +0200)
1  2 
lib/pleroma/web/activity_pub/activity_pub.ex
lib/pleroma/web/common_api/utils.ex
lib/pleroma/web/router.ex

index 6973360195061c2eeb3fbb7b3ff6551652e280c6,8baaf97ac822348975ae8ec7fb2a36b880cf93ee..75b7b1b5979c5368f914ff6d0b700ab818f63e6a
@@@ -126,14 -126,7 +126,14 @@@ defmodule Pleroma.Web.ActivityPub.Activ
  
    def increase_poll_votes_if_vote(_create_data), do: :noop
  
 +  @object_types ["ChatMessage"]
    @spec persist(map(), keyword()) :: {:ok, Activity.t() | Object.t()}
 +  def persist(%{"type" => type} = object, meta) when type in @object_types do
 +    with {:ok, object} <- Object.create(object) do
 +      {:ok, object, meta}
 +    end
 +  end
 +
    def persist(object, meta) do
      with local <- Keyword.fetch!(meta, :local),
           {recipients, _, _} <- get_recipients(object),
  
        BackgroundWorker.enqueue("fetch_data_for_activity", %{"activity_id" => activity.id})
  
-       Notification.create_notifications(activity)
-       conversation = create_or_bump_conversation(activity, map["actor"])
-       participations = get_participations(conversation)
-       stream_out(activity)
-       stream_out_participations(participations)
        {:ok, activity}
      else
        %Activity{} = activity ->
      end
    end
  
+   def notify_and_stream(activity) do
+     Notification.create_notifications(activity)
+     conversation = create_or_bump_conversation(activity, activity.actor)
+     participations = get_participations(conversation)
+     stream_out(activity)
+     stream_out_participations(participations)
+   end
    defp create_or_bump_conversation(activity, actor) do
      with {:ok, conversation} <- Conversation.create_or_bump_for(activity),
           %User{} = user <- User.get_cached_by_ap_id(actor),
           _ <- increase_poll_votes_if_vote(create_data),
           {:quick_insert, false, activity} <- {:quick_insert, quick_insert?, activity},
           {:ok, _actor} <- increase_note_count_if_public(actor, activity),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity}
      else
               additional
             ),
           {:ok, activity} <- insert(listen_data, local),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity}
      end
             %{"to" => to, "type" => type, "actor" => actor.ap_id, "object" => object}
             |> Utils.maybe_put("id", activity_id),
           {:ok, activity} <- insert(data, local),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity}
      end
           },
           data <- Utils.maybe_put(data, "id", activity_id),
           {:ok, activity} <- insert(data, local),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity}
      end
           reaction_data <- make_emoji_reaction_data(user, object, emoji, activity_id),
           {:ok, activity} <- insert(reaction_data, local),
           {:ok, object} <- add_emoji_reaction_to_object(activity, object),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity, object}
      else
           unreact_data <- make_undo_data(user, reaction_activity, activity_id),
           {:ok, activity} <- insert(unreact_data, local),
           {:ok, object} <- remove_emoji_reaction_from_object(reaction_activity, object),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity, object}
      else
           {:ok, unlike_activity} <- insert(unlike_data, local),
           {:ok, _activity} <- Repo.delete(like_activity),
           {:ok, object} <- remove_like_from_object(like_activity, object),
+          _ <- notify_and_stream(unlike_activity),
           :ok <- maybe_federate(unlike_activity) do
        {:ok, unlike_activity, like_activity, object}
      else
           announce_data <- make_announce_data(user, object, activity_id, public),
           {:ok, activity} <- insert(announce_data, local),
           {:ok, object} <- add_announce_to_object(activity, object),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity, object}
      else
      with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
           unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
           {:ok, unannounce_activity} <- insert(unannounce_data, local),
+          _ <- notify_and_stream(unannounce_activity),
           :ok <- maybe_federate(unannounce_activity),
           {:ok, _activity} <- Repo.delete(announce_activity),
           {:ok, object} <- remove_announce_from_object(announce_activity, object) do
    defp do_follow(follower, followed, activity_id, local) do
      with data <- make_follow_data(follower, followed, activity_id),
           {:ok, activity} <- insert(data, local),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity}
      else
           {:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
           unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
           {:ok, activity} <- insert(unfollow_data, local),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity}
      else
      with true <- outgoing_blocks,
           block_data <- make_block_data(blocker, blocked, activity_id),
           {:ok, activity} <- insert(block_data, local),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity}
      else
      with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
           unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
           {:ok, activity} <- insert(unblock_data, local),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(activity) do
        {:ok, activity}
      else
      with flag_data <- make_flag_data(params, additional),
           {:ok, activity} <- insert(flag_data, local),
           {:ok, stripped_activity} <- strip_report_status_data(activity),
+          _ <- notify_and_stream(activity),
           :ok <- maybe_federate(stripped_activity) do
        User.all_superusers()
        |> Enum.filter(fn user -> not is_nil(user.email) end)
      }
  
      with true <- origin.ap_id in target.also_known_as,
-          {:ok, activity} <- insert(params, local) do
+          {:ok, activity} <- insert(params, local),
+          _ <- notify_and_stream(activity) do
        maybe_federate(activity)
  
        BackgroundWorker.enqueue("move_following", %{
      end
    end
  
 +  defp exclude_chat_messages(query, %{"include_chat_messages" => true}), do: query
 +
 +  defp exclude_chat_messages(query, _) do
 +    if has_named_binding?(query, :object) do
 +      from([activity, object: o] in query,
 +        where: fragment("not(?->>'type' = ?)", o.data, "ChatMessage")
 +      )
 +    else
 +      query
 +    end
 +  end
 +
    defp exclude_id(query, %{"exclude_id" => id}) when is_binary(id) do
      from(activity in query, where: activity.id != ^id)
    end
      |> restrict_instance(opts)
      |> Activity.restrict_deactivated_users()
      |> exclude_poll_votes(opts)
 +    |> exclude_chat_messages(opts)
      |> exclude_visibility(opts)
    end
  
index b0b1bd559ae235e0cbf2479f90d20c04306b2274,793f2e7f8e6356e3dab3e9725c505b78fa1e5652..47fd6a523f10a8242f18e1188573a42c88079d0a
@@@ -402,6 -402,7 +402,7 @@@ defmodule Pleroma.Web.CommonAPI.Utils d
      end
    end
  
+   @spec confirm_current_password(User.t(), String.t()) :: {:ok, User.t()} | {:error, String.t()}
    def confirm_current_password(user, password) do
      with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
           true <- AuthenticationPlug.checkpw(password, db_user.password_hash) do
          %Activity{data: %{"to" => _to, "type" => type} = data} = activity
        )
        when type == "Create" do
 -    object = Object.normalize(activity)
 +    object = Object.normalize(activity, false)
  
      object_data =
        cond do
index 6b16cfa5d9af9e3fa0f688000be8f43ef3bd0512,7a171f9fbf6462091e132aafe8fa4ca2dd76803e..4b264c43ec1bea39a6b6f2297925457e7f39d3fe
@@@ -132,6 -132,7 +132,7 @@@ defmodule Pleroma.Web.Router d
      post("/users/follow", AdminAPIController, :user_follow)
      post("/users/unfollow", AdminAPIController, :user_unfollow)
  
+     put("/users/disable_mfa", AdminAPIController, :disable_mfa)
      delete("/users", AdminAPIController, :user_delete)
      post("/users", AdminAPIController, :users_create)
      patch("/users/:nickname/toggle_activation", AdminAPIController, :user_toggle_activation)
      post("/follow_import", UtilController, :follow_import)
    end
  
+   scope "/api/pleroma", Pleroma.Web.PleromaAPI do
+     pipe_through(:authenticated_api)
+     get("/accounts/mfa", TwoFactorAuthenticationController, :settings)
+     get("/accounts/mfa/backup_codes", TwoFactorAuthenticationController, :backup_codes)
+     get("/accounts/mfa/setup/:method", TwoFactorAuthenticationController, :setup)
+     post("/accounts/mfa/confirm/:method", TwoFactorAuthenticationController, :confirm)
+     delete("/accounts/mfa/:method", TwoFactorAuthenticationController, :disable)
+   end
    scope "/oauth", Pleroma.Web.OAuth do
      scope [] do
        pipe_through(:oauth)
      post("/revoke", OAuthController, :token_revoke)
      get("/registration_details", OAuthController, :registration_details)
  
+     post("/mfa/challenge", MFAController, :challenge)
+     post("/mfa/verify", MFAController, :verify, as: :mfa_verify)
+     get("/mfa", MFAController, :show)
      scope [] do
        pipe_through(:browser)
  
    end
  
    scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
 +    scope [] do
 +      pipe_through(:authenticated_api)
 +
 +      post("/chats/by-account-id/:id", ChatController, :create)
 +      get("/chats", ChatController, :index)
 +      get("/chats/:id/messages", ChatController, :messages)
 +      post("/chats/:id/messages", ChatController, :post_chat_message)
 +      post("/chats/:id/read", ChatController, :mark_as_read)
 +    end
 +
      scope [] do
        pipe_through(:authenticated_api)