Merge branch 'feature/status-counts-by-scope' into 'develop'

Stats: return status counts by scope

See merge request pleroma/pleroma!2076

CHANGELOG.md

@@ -29,6 +29,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - **Breaking:** Admin API: `PUT /api/pleroma/admin/reports/:id` is now `PATCH /api/pleroma/admin/reports`, see admin_api.md for details
 - **Breaking:** `/api/pleroma/admin/users/invite_token` now uses `POST`, changed accepted params and returns full invite in json instead of only token string.
 - **Breaking** replying to reports is now "report notes", enpoint changed from `POST /api/pleroma/admin/reports/:id/respond` to `POST /api/pleroma/admin/reports/:id/notes`
+- **Breaking** `/api/v1/stats` now return statuses count by scope (i.e. `all`, `public`, `unlisted`, `direct` and `private`)
 - Admin API: Return `total` when querying for reports
 - Mastodon API: Return `pleroma.direct_conversation_id` when creating a direct message (`POST /api/v1/statuses`)
 - Admin API: Return link alongside with token on password reset

lib/pleroma/stats.ex

@@ -3,11 +3,15 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Stats do
+  use GenServer
+
   import Ecto.Query
+
+  alias Pleroma.Object
   alias Pleroma.Repo
   alias Pleroma.User
 
-  use GenServer
+  require Pleroma.Constants
 
   @interval 1000 * 60 * 60
 
@@ -56,7 +60,7 @@ defp initial_data do
     %{peers: [], stats: %{}}
   end
 
-  defp get_stat_data do
+  def get_stat_data do
     peers =
       from(
         u in User,
@@ -68,13 +72,71 @@ defp get_stat_data do
 
     domain_count = Enum.count(peers)
 
-    status_count = Repo.aggregate(User.Query.build(%{local: true}), :sum, :note_count)
-
     user_count = Repo.aggregate(User.Query.build(%{local: true, active: true}), :count, :id)
 
     %{
       peers: peers,
-      stats: %{domain_count: domain_count, status_count: status_count, user_count: user_count}
+      stats: %{domain_count: domain_count, status_count: status_count(), user_count: user_count}
     }
   end
+
+  defp status_count do
+    %{
+      all: all_statuses_query() |> Repo.aggregate(:count, :id),
+      public: public_statuses_query() |> Repo.aggregate(:count, :id),
+      unlisted: unlisted_statuses_query() |> Repo.aggregate(:count, :id),
+      direct: direct_statuses_query() |> Repo.aggregate(:count, :id),
+      private: private_statuses_query() |> Repo.aggregate(:count, :id)
+    }
+  end
+
+  defp all_statuses_query do
+    from(o in Object, where: fragment("(?)->>'type' = 'Note'", o.data))
+  end
+
+  def public_statuses_query do
+    from(o in Object,
+      where: fragment("(?)->'to' \\? ?", o.data, ^Pleroma.Constants.as_public())
+    )
+  end
+
+  def unlisted_statuses_query do
+    from(o in Object,
+      where: not fragment("(?)->'to' \\? ?", o.data, ^Pleroma.Constants.as_public()),
+      where: fragment("(?)->'cc' \\? ?", o.data, ^Pleroma.Constants.as_public())
+    )
+  end
+
+  def direct_statuses_query do
+    private_statuses_ids = from(p in private_statuses_query(), select: p.id) |> Repo.all()
+
+    from(o in Object,
+      where:
+        fragment(
+          "? \\? 'directMessage' AND (?->>'directMessage')::boolean = true",
+          o.data,
+          o.data
+        ) or
+          (not fragment("(?)->'to' \\? ?", o.data, ^Pleroma.Constants.as_public()) and
+             not fragment("(?)->'cc' \\? ?", o.data, ^Pleroma.Constants.as_public()) and
+             o.id not in ^private_statuses_ids)
+    )
+  end
+
+  def private_statuses_query do
+    from(o in subquery(recipients_query()),
+      where: ilike(o.recipients, "%/followers%")
+    )
+  end
+
+  defp recipients_query do
+    from(o in Object,
+      select: %{
+        id: o.id,
+        recipients: fragment("jsonb_array_elements_text((?)->'to')", o.data)
+      },
+      where: not fragment("(?)->'to' \\? ?", o.data, ^Pleroma.Constants.as_public()),
+      where: not fragment("(?)->'cc' \\? ?", o.data, ^Pleroma.Constants.as_public())
+    )
+  end
 end

test/stats_test.exs

@@ -0,0 +1,53 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.StatsTest do
+  use Pleroma.DataCase
+
+  import Pleroma.Factory
+
+  alias Pleroma.Web.CommonAPI
+
+  describe "statuses count" do
+    setup do
+      user = insert(:user)
+      other_user = insert(:user)
+
+      CommonAPI.post(user, %{"visibility" => "public", "status" => "hey"})
+
+      Enum.each(0..1, fn _ ->
+        CommonAPI.post(user, %{
+          "visibility" => "unlisted",
+          "status" => "hey"
+        })
+      end)
+
+      Enum.each(0..2, fn _ ->
+        CommonAPI.post(user, %{
+          "visibility" => "direct",
+          "status" => "hey @#{other_user.nickname}"
+        })
+      end)
+
+      Enum.each(0..3, fn _ ->
+        CommonAPI.post(user, %{
+          "visibility" => "private",
+          "status" => "hey"
+        })
+      end)
+
+      :ok
+    end
+
+    test "it returns total number of statuses" do
+      data = Pleroma.Stats.get_stat_data()
+
+      assert data.stats.status_count.all == 10
+      assert data.stats.status_count.public == 1
+      assert data.stats.status_count.unlisted == 2
+      assert data.stats.status_count.direct == 3
+      assert data.stats.status_count.private == 4
+    end
+  end
+end

test/web/mastodon_api/controllers/instance_controller_test.exs

@@ -58,7 +58,15 @@ test "get instance stats", %{conn: conn} do
 
     assert stats
     assert stats["user_count"] == 1
-    assert stats["status_count"] == 1
+
+    assert stats["status_count"] == %{
+             "all" => 1,
+             "direct" => 0,
+             "private" => 0,
+             "public" => 1,
+             "unlisted" => 0
+           }
+
     assert stats["domain_count"] == 2
   end