[PAY-487] DN - Handle premium track access for track apis (#3783)

* Add has_current_user_unlocked and premium_content_signature to premium tracks in populate_track_metadata

* Extract populate premium track metadata method

* Add premium content logic to get_single_track flow

* Exclude premium tracks from public api latest track

* Handle premium track fitler for v1 track routes

* Grant premium track access to owner of that track

* Handle premium tracks in search api flows

* Improve popuplate premium track metadata logic

* Filter out premium tracks in public playlist apis

* Rename filter_premium to exclude_premium for clarity

* Refactor track_dsl with premium filter

* Fix lint

* Rename premium content constants file

* Temporarily comment out premium access check in social features and user library

* Fix circular dependency

* Fix populate premium track metadata

* Fix get_feed_es integration test

* Update premium content access checker and handle reposts and saves

* Address PR comments

* Fix get_feed_es merge issue

* Update es track indexer

* Filter out premium tracks from feed

* Check premium content access for social features

* Move social feature functions to social_features.py

* Implement premium content access check for one entity

* Update tests

* Fix tests

* Update comment

* Move social features premium access check to validation fn

* Update generated types for premium content

* Update generate_signature use

* Exlude premium tracks from recommended tracks

Co-authored-by: Saliou Diallo <[email protected]>

Author: sddioulde

discovery-provider/es-indexer/src/indexNames.ts

@@ -2,6 +2,6 @@ export const indexNames = {
   playlists: 'playlists7',
   reposts: 'reposts2',
   saves: 'saves2',
-  tracks: 'tracks7',
+  tracks: 'tracks8',
   users: 'users7',
 }

discovery-provider/es-indexer/src/indexers/TrackIndexer.ts

@@ -67,6 +67,7 @@ export class TrackIndexer extends BaseIndexer<TrackDoc> {
         mood: { type: 'keyword' },
         is_delete: { type: 'boolean' },
         is_unlisted: { type: 'boolean' },
+        is_premium: { type: 'boolean' },
         downloadable: { type: 'boolean' },
 
         // saves

discovery-provider/integration_tests/premium_content/test_access.py

@@ -1,80 +1,181 @@
 from integration_tests.utils import populate_mock_db
+from src.models.tracks.track import Track
 from src.premium_content.premium_content_access_checker import (
     PremiumContentAccessChecker,
 )
 from src.utils.db_session import get_db_read_replica
 
 
-def test_track_access(app):
+def test_access(app):
+    non_premium_track_entity = {
+        "track_id": 1,
+        "owner_id": 3,
+        "is_premium": False,
+        "premium_conditions": None,
+    }
+    premium_track_entity_1 = {
+        "track_id": 2,
+        "owner_id": 3,
+        "is_premium": True,
+        "premium_conditions": {"nft-collection": "some-nft-collection"},
+    }
+    premium_track_entity_2 = {
+        "track_id": 3,
+        "owner_id": 2,
+        "is_premium": True,
+        "premium_conditions": {"nft-collection": "some-nft-collection"},
+    }
+    track_entities = [
+        non_premium_track_entity,
+        premium_track_entity_1,
+        premium_track_entity_2,
+    ]
+    tracks = []
+    for entity in track_entities:
+        tracks.append(
+            Track(
+                blockhash=hex(0),
+                blocknumber=0,
+                txhash=str(0),
+                track_id=entity.get("track_id"),
+                owner_id=entity.get("owner_id", 1),
+                is_premium=entity.get("is_premium", False),
+                premium_conditions=entity.get("premium_conditions", None),
+                is_current=True,
+                is_delete=False,
+            )
+        )
+
+    premium_content_access_checker = PremiumContentAccessChecker()
+
+    # test non-premium content
+    result = premium_content_access_checker.check_access(
+        user_id=1,
+        premium_content_id=non_premium_track_entity["track_id"],
+        premium_content_type="track",
+        premium_content_entity=tracks[0],
+    )
+    assert not result["is_premium"] and result["does_user_have_access"]
+
+    # test premium content with user who has access
+    result = premium_content_access_checker.check_access(
+        user_id=2,
+        premium_content_id=premium_track_entity_1["track_id"],
+        premium_content_type="track",
+        premium_content_entity=tracks[1],
+    )
+    assert result["is_premium"] and result["does_user_have_access"]
+
+    # test premium content with user who owns the track
+    result = premium_content_access_checker.check_access(
+        user_id=2,
+        premium_content_id=premium_track_entity_2["track_id"],
+        premium_content_type="track",
+        premium_content_entity=tracks[2],
+    )
+    assert result["is_premium"] and result["does_user_have_access"]
+
+    # todo: test premium content with user who has no access
+    # after we implement nft infexing
+
+
+def test_batch_access(app):
     with app.app_context():
         db = get_db_read_replica()
 
         user_entity_1 = {"user_id": 1}
         user_entity_2 = {"user_id": 2}
-        user_entities = [user_entity_1, user_entity_2]
+        user_entity_3 = {"user_id": 3}
+        user_entities = [user_entity_1, user_entity_2, user_entity_3]
+
+        non_exisent_track_id = 1
 
         non_premium_track_entity = {
-            "track_id": 1,
+            "track_id": 2,
             "is_premium": False,
             "premium_conditions": None,
         }
-        premium_track_entity = {
-            "track_id": 2,
+        premium_track_entity_1 = {
+            "track_id": 3,
+            "is_premium": True,
+            "premium_conditions": {"nft-collection": "some-nft-collection"},
+        }
+        premium_track_entity_2 = {
+            "track_id": 4,
+            "owner_id": user_entity_3["user_id"],
             "is_premium": True,
             "premium_conditions": {"nft-collection": "some-nft-collection"},
         }
-        track_entities = [non_premium_track_entity, premium_track_entity]
+        track_entities = [
+            non_premium_track_entity,
+            premium_track_entity_1,
+            premium_track_entity_2,
+        ]
 
         entities = {"users": user_entities, "tracks": track_entities}
 
         populate_mock_db(db, entities)
 
         premium_content_access_checker = PremiumContentAccessChecker()
 
-        non_exisent_track_id = 3
-
-        result = premium_content_access_checker.check_access_for_batch(
-            [
-                {
-                    "user_id": user_entity_1["user_id"],
-                    "premium_content_id": non_exisent_track_id,
-                    "premium_content_type": "track",
-                },
-                {
-                    "user_id": user_entity_2["user_id"],
-                    "premium_content_id": non_premium_track_entity["track_id"],
-                    "premium_content_type": "track",
-                },
-                {
-                    "user_id": user_entity_2["user_id"],
-                    "premium_content_id": premium_track_entity["track_id"],
-                    "premium_content_type": "track",
-                },
-            ]
-        )
+        with db.scoped_session() as session:
+            result = premium_content_access_checker.check_access_for_batch(
+                session,
+                [
+                    {
+                        "user_id": user_entity_1["user_id"],
+                        "premium_content_id": non_exisent_track_id,
+                        "premium_content_type": "track",
+                    },
+                    {
+                        "user_id": user_entity_2["user_id"],
+                        "premium_content_id": non_premium_track_entity["track_id"],
+                        "premium_content_type": "track",
+                    },
+                    {
+                        "user_id": user_entity_2["user_id"],
+                        "premium_content_id": premium_track_entity_1["track_id"],
+                        "premium_content_type": "track",
+                    },
+                    {
+                        "user_id": user_entity_3["user_id"],
+                        "premium_content_id": premium_track_entity_2["track_id"],
+                        "premium_content_type": "track",
+                    },
+                ],
+            )
 
-        track_access_result = result["track"]
+            track_access_result = result["track"]
 
-        # test non-existent track
-        assert user_entity_1["user_id"] not in track_access_result
+            # test non-existent track
+            assert user_entity_1["user_id"] not in track_access_result
 
-        # test non-premium track
-        user_2_non_premium_track_access_result = track_access_result[
-            user_entity_2["user_id"]
-        ][non_premium_track_entity["track_id"]]
-        assert (
-            not user_2_non_premium_track_access_result["is_premium"]
-            and user_2_non_premium_track_access_result["does_user_have_access"]
-        )
+            # test non-premium track
+            user_2_non_premium_track_access_result = track_access_result[
+                user_entity_2["user_id"]
+            ][non_premium_track_entity["track_id"]]
+            assert (
+                not user_2_non_premium_track_access_result["is_premium"]
+                and user_2_non_premium_track_access_result["does_user_have_access"]
+            )
 
-        # test premium track with user who has access
-        user_2_premium_track_access_result = track_access_result[
-            user_entity_2["user_id"]
-        ][premium_track_entity["track_id"]]
-        assert (
-            user_2_premium_track_access_result["is_premium"]
-            and user_2_premium_track_access_result["does_user_have_access"]
-        )
+            # test premium track with user who has access
+            user_2_premium_track_access_result = track_access_result[
+                user_entity_2["user_id"]
+            ][premium_track_entity_1["track_id"]]
+            assert (
+                user_2_premium_track_access_result["is_premium"]
+                and user_2_premium_track_access_result["does_user_have_access"]
+            )
+
+            # test premium track with user who owns the track
+            user_3_premium_track_access_result = track_access_result[
+                user_entity_3["user_id"]
+            ][premium_track_entity_2["track_id"]]
+            assert (
+                user_3_premium_track_access_result["is_premium"]
+                and user_3_premium_track_access_result["does_user_have_access"]
+            )
 
-        # todo: test premium track with user who has no access
-        # after we implement nft infexing
+            # todo: test premium track with user who has no access
+            # after we implement nft infexing

discovery-provider/integration_tests/queries/test_populate_track_metadata.py

@@ -54,9 +54,9 @@ def test_populate_track_metadata(app):
     with db.scoped_session() as session:
         track_ids = [1, 2, 3]
         tracks = [
-            {"track_id": 1},
-            {"track_id": 2},
-            {"track_id": 3},
+            {"track_id": 1, "is_premium": False},
+            {"track_id": 2, "is_premium": False},
+            {"track_id": 3, "is_premium": False},
         ]
 
         tracks = populate_track_metadata(session, track_ids, tracks, None)
@@ -78,7 +78,11 @@ def test_populate_track_metadata(app):
         assert tracks[2][response_name_constants.play_count] == 0
 
         curr_track_ids = [1, 2, 3]
-        curr_tracks = [{"track_id": 1}, {"track_id": 2}, {"track_id": 3}]
+        curr_tracks = [
+            {"track_id": 1, "is_premium": False},
+            {"track_id": 2, "is_premium": False},
+            {"track_id": 3, "is_premium": False},
+        ]
 
         tracks = populate_track_metadata(session, curr_track_ids, curr_tracks, 1)
         assert len(tracks) == 3

discovery-provider/integration_tests/tasks/entity_manager/test_social_feature_entity_manager.py

@@ -139,7 +139,6 @@ def get_events_side_effect(_, tx_receipt):
         side_effect=get_events_side_effect,
         autospec=True,
     )
-    test_metadata = {}
 
     entities = {
         "users": [
@@ -163,7 +162,7 @@ def get_events_side_effect(_, tx_receipt):
             block_number=1,
             block_timestamp=1585336422,
             block_hash=0,
-            ipfs_metadata=test_metadata,
+            ipfs_metadata={},
         )
 
         # Verify follows
@@ -298,7 +297,6 @@ def get_events_side_effect(_, tx_receipt):
         side_effect=get_events_side_effect,
         autospec=True,
     )
-    test_metadata = {}
 
     entities = {
         "users": [
@@ -322,7 +320,7 @@ def get_events_side_effect(_, tx_receipt):
             block_number=1,
             block_timestamp=1585336422,
             block_hash=0,
-            ipfs_metadata=test_metadata,
+            ipfs_metadata={},
         )
 
         # Verify follows

discovery-provider/integration_tests/tasks/entity_manager/test_track_entity_manager.py

@@ -129,6 +129,8 @@ def get_events_side_effect(_, tx_receipt):
             "has_current_user_reposted": False,
             "is_current": True,
             "is_unlisted": False,
+            "is_premium": False,
+            "premium_conditions": None,
             "field_visibility": {
                 "mood": True,
                 "tags": True,
@@ -171,6 +173,8 @@ def get_events_side_effect(_, tx_receipt):
             "has_current_user_reposted": False,
             "is_current": True,
             "is_unlisted": False,
+            "is_premium": False,
+            "premium_conditions": None,
             "field_visibility": {
                 "genre": True,
                 "mood": True,
@@ -211,6 +215,8 @@ def get_events_side_effect(_, tx_receipt):
             "has_current_user_reposted": False,
             "is_current": True,
             "is_unlisted": False,
+            "is_premium": False,
+            "premium_conditions": None,
             "field_visibility": {
                 "mood": True,
                 "tags": True,

discovery-provider/integration_tests/tasks/test_get_feed_es.py

@@ -71,10 +71,11 @@ def test_get_feed_es(app):
     assert len(search_res) == 8
 
     # test feed
-    feed_results = get_feed_es({"user_id": "1"})
-    assert feed_results[0]["playlist_id"] == 1
-    assert feed_results[0]["save_count"] == 1
-    assert len(feed_results[0]["followee_reposts"]) == 1
+    with app.app_context():
+        feed_results = get_feed_es({"user_id": "1"})
+        assert feed_results[0]["playlist_id"] == 1
+        assert feed_results[0]["save_count"] == 1
+        assert len(feed_results[0]["followee_reposts"]) == 1
 
-    assert feed_results[1]["track_id"] == 1
-    assert feed_results[1]["save_count"] == 1
+        assert feed_results[1]["track_id"] == 1
+        assert feed_results[1]["save_count"] == 1

discovery-provider/src/api/v1/models/tracks.py

@@ -70,6 +70,12 @@
         "remixes": fields.Boolean,
     },
 )
+premium_conditions = ns.model(
+    "premium_conditions",
+    {
+        "nft-collection": fields.String,
+    },
+)
 track = ns.model(
     "Track",
     {
@@ -125,6 +131,8 @@
         "cover_art": fields.String,
         "remix_of": fields.Nested(full_remix_parent),
         "is_available": fields.Boolean,
+        "is_premium": fields.Boolean,
+        "premium_conditions": fields.Nested(premium_conditions),
     },
 )
 

discovery-provider/src/api/v1/playlists.py

@@ -86,13 +86,14 @@ def get_playlist(playlist_id, current_user_id):
     return None
 
 
-def get_tracks_for_playlist(playlist_id, current_user_id=None):
+def get_tracks_for_playlist(playlist_id, current_user_id=None, exclude_premium=False):
     db = get_db_read_replica()
     with db.scoped_session() as session:
         args = {
             "playlist_ids": [playlist_id],
             "populate_tracks": True,
             "current_user_id": current_user_id,
+            "exclude_premium": exclude_premium,
         }
         playlist_tracks_map = get_playlist_tracks(session, args)
         playlist_tracks = playlist_tracks_map[playlist_id]
@@ -164,7 +165,7 @@ class PlaylistTracks(Resource):
     @cache(ttl_sec=5)
     def get(self, playlist_id):
         decoded_id = decode_with_abort(playlist_id, ns)
-        tracks = get_tracks_for_playlist(decoded_id)
+        tracks = get_tracks_for_playlist(playlist_id=decoded_id, exclude_premium=True)
         return success_response(tracks)