X-Git-Url: http://git.squeep.com/?a=blobdiff_plain;f=priv%2Frepo%2Fmigrations%2F20191007073319_create_following_relationships.exs;h=d49e24ee4804acecde33e7018cae9206fd96638d;hb=ae54c06bb4bd2389d6eb1502b842c6b632e12e40;hp=7b8a2f9bdd9546c426747d81800cce1fa93a836a;hpb=12ebeef1300b70e44b2aa25dbffeb82df261e26d;p=akkoma

diff --git a/priv/repo/migrations/20191007073319_create_following_relationships.exs b/priv/repo/migrations/20191007073319_create_following_relationships.exs
index 7b8a2f9bd..d49e24ee4 100644
--- a/priv/repo/migrations/20191007073319_create_following_relationships.exs
+++ b/priv/repo/migrations/20191007073319_create_following_relationships.exs
@@ -1,11 +1,6 @@
 defmodule Pleroma.Repo.Migrations.CreateFollowingRelationships do
   use Ecto.Migration
 
-  # had to disable these to be able to restore `following` index concurrently
-  # https://hexdocs.pm/ecto_sql/Ecto.Migration.html#index/3-adding-dropping-indexes-concurrently
-  @disable_ddl_transaction true
-  @disable_migration_lock true
-
   def change do
     create_if_not_exists table(:following_relationships) do
       add(:follower_id, references(:users, type: :uuid, on_delete: :delete_all), null: false)
@@ -18,75 +13,137 @@ defmodule Pleroma.Repo.Migrations.CreateFollowingRelationships do
     create_if_not_exists(index(:following_relationships, :follower_id))
     create_if_not_exists(unique_index(:following_relationships, [:follower_id, :following_id]))
 
-    execute(insert_following_relationships_rows(), restore_following_column())
-
-    drop(index(:users, [:following], concurrently: true, using: :gin))
-
-    alter table(:users) do
-      remove(:following, {:array, :string}, default: [])
-    end
+    execute(update_thread_visibility(), restore_thread_visibility())
   end
 
-  defp insert_following_relationships_rows do
+  # The only difference between the original version: `actor_user` replaced with `actor_user_following`
+  def update_thread_visibility do
     """
-    INSERT INTO
-        following_relationships (
-            follower_id,
-            following_id,
-            state,
-            inserted_at,
-            updated_at
-        )
-    SELECT
-        followers.id,
-        following.id,
-        activities.data ->> 'state',
-        (activities.data ->> 'published') :: timestamp,
-        now()
-    FROM
-        activities
-        JOIN users AS followers ON (activities.actor = followers.ap_id)
-        JOIN users AS following ON (activities.data ->> 'object' = following.ap_id)
-    WHERE
-        activities.data ->> 'type' = 'Follow'
-        AND activities.data ->> 'state' IN ('accept', 'pending', 'reject') ON CONFLICT DO NOTHING
+    CREATE OR REPLACE FUNCTION thread_visibility(actor varchar, activity_id varchar) RETURNS boolean AS $$
+    DECLARE
+      public varchar := 'https://www.w3.org/ns/activitystreams#Public';
+      child objects%ROWTYPE;
+      activity activities%ROWTYPE;
+      author_fa varchar;
+      valid_recipients varchar[];
+      actor_user_following varchar[];
+    BEGIN
+      --- Fetch actor following
+      SELECT array_agg(following.follower_address) INTO actor_user_following FROM following_relationships
+      JOIN users ON users.id = following_relationships.follower_id
+      JOIN users AS following ON following.id = following_relationships.following_id
+      WHERE users.ap_id = actor;
+
+      --- Fetch our initial activity.
+      SELECT * INTO activity FROM activities WHERE activities.data->>'id' = activity_id;
+
+      LOOP
+        --- Ensure that we have an activity before continuing.
+        --- If we don't, the thread is not satisfiable.
+        IF activity IS NULL THEN
+          RETURN false;
+        END IF;
+
+        --- We only care about Create activities.
+        IF activity.data->>'type' != 'Create' THEN
+          RETURN true;
+        END IF;
+
+        --- Normalize the child object into child.
+        SELECT * INTO child FROM objects
+        INNER JOIN activities ON COALESCE(activities.data->'object'->>'id', activities.data->>'object') = objects.data->>'id'
+        WHERE COALESCE(activity.data->'object'->>'id', activity.data->>'object') = objects.data->>'id';
+
+        --- Fetch the author's AS2 following collection.
+        SELECT COALESCE(users.follower_address, '') INTO author_fa FROM users WHERE users.ap_id = activity.actor;
+
+        --- Prepare valid recipients array.
+        valid_recipients := ARRAY[actor, public];
+        IF ARRAY[author_fa] && actor_user_following THEN
+          valid_recipients := valid_recipients || author_fa;
+        END IF;
+
+        --- Check visibility.
+        IF NOT valid_recipients && activity.recipients THEN
+          --- activity not visible, break out of the loop
+          RETURN false;
+        END IF;
+
+        --- If there's a parent, load it and do this all over again.
+        IF (child.data->'inReplyTo' IS NOT NULL) AND (child.data->'inReplyTo' != 'null'::jsonb) THEN
+          SELECT * INTO activity FROM activities
+          INNER JOIN objects ON COALESCE(activities.data->'object'->>'id', activities.data->>'object') = objects.data->>'id'
+          WHERE child.data->>'inReplyTo' = objects.data->>'id';
+        ELSE
+          RETURN true;
+        END IF;
+      END LOOP;
+    END;
+    $$ LANGUAGE plpgsql IMMUTABLE;
     """
   end
 
-  defp restore_following_column do
+  # priv/repo/migrations/20190515222404_add_thread_visibility_function.exs
+  def restore_thread_visibility do
     """
-    UPDATE
-        users
-    SET
-        following = following_query.following,
-        updated_at = now()
-    FROM
-        (
-            SELECT
-                followers.id AS follower_id,
-                array_prepend(
-                    followers.follower_address,
-                    array_agg(DISTINCT following.ap_id) FILTER (
-                        WHERE
-                            following.ap_id IS NOT NULL
-                    )
-                ) as following
-            FROM
-                users AS followers
-                LEFT OUTER JOIN activities ON (
-                    followers.ap_id = activities.actor
-                    AND activities.data ->> 'type' = 'Follow'
-                    AND activities.data ->> 'state' IN ('accept', 'pending', 'reject')
-                )
-                LEFT OUTER JOIN users AS following ON (activities.data ->> 'object' = following.ap_id)
-            WHERE
-                followers.email IS NOT NULL  -- Exclude `internal/fetch` and `relay`
-            GROUP BY
-                followers.id,
-                followers.ap_id
-        ) AS following_query
-    WHERE
-        following_query.follower_id = users.id;
+    CREATE OR REPLACE FUNCTION thread_visibility(actor varchar, activity_id varchar) RETURNS boolean AS $$
+    DECLARE
+      public varchar := 'https://www.w3.org/ns/activitystreams#Public';
+      child objects%ROWTYPE;
+      activity activities%ROWTYPE;
+      actor_user users%ROWTYPE;
+      author_fa varchar;
+      valid_recipients varchar[];
+    BEGIN
+      --- Fetch our actor.
+      SELECT * INTO actor_user FROM users WHERE users.ap_id = actor;
+
+      --- Fetch our initial activity.
+      SELECT * INTO activity FROM activities WHERE activities.data->>'id' = activity_id;
+
+      LOOP
+        --- Ensure that we have an activity before continuing.
+        --- If we don't, the thread is not satisfiable.
+        IF activity IS NULL THEN
+          RETURN false;
+        END IF;
+
+        --- We only care about Create activities.
+        IF activity.data->>'type' != 'Create' THEN
+          RETURN true;
+        END IF;
+
+        --- Normalize the child object into child.
+        SELECT * INTO child FROM objects
+        INNER JOIN activities ON COALESCE(activities.data->'object'->>'id', activities.data->>'object') = objects.data->>'id'
+        WHERE COALESCE(activity.data->'object'->>'id', activity.data->>'object') = objects.data->>'id';
+
+        --- Fetch the author's AS2 following collection.
+        SELECT COALESCE(users.follower_address, '') INTO author_fa FROM users WHERE users.ap_id = activity.actor;
+
+        --- Prepare valid recipients array.
+        valid_recipients := ARRAY[actor, public];
+        IF ARRAY[author_fa] && actor_user.following THEN
+          valid_recipients := valid_recipients || author_fa;
+        END IF;
+
+        --- Check visibility.
+        IF NOT valid_recipients && activity.recipients THEN
+          --- activity not visible, break out of the loop
+          RETURN false;
+        END IF;
+
+        --- If there's a parent, load it and do this all over again.
+        IF (child.data->'inReplyTo' IS NOT NULL) AND (child.data->'inReplyTo' != 'null'::jsonb) THEN
+          SELECT * INTO activity FROM activities
+          INNER JOIN objects ON COALESCE(activities.data->'object'->>'id', activities.data->>'object') = objects.data->>'id'
+          WHERE child.data->>'inReplyTo' = objects.data->>'id';
+        ELSE
+          RETURN true;
+        END IF;
+      END LOOP;
+    END;
+    $$ LANGUAGE plpgsql IMMUTABLE;
     """
   end
 end