Add user track favorites (#886)

* Add full user track favorites endpoint

* Fix lint and error with get playlist savers

* Rename get full save tracks w/out full

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

@@ -8,6 +8,7 @@
 from src.queries.get_users import get_users
 from src.queries.search_queries import SearchKind, search
 from src.queries.get_tracks import get_tracks
+from src.queries.get_save_tracks import get_save_tracks
 from src.queries.get_followees_for_user import get_followees_for_user
 from src.queries.get_followers_for_user import get_followers_for_user
 
@@ -402,6 +403,48 @@ def get(self, user_id):
         favorites = list(map(extend_favorite, favorites))
         return success_response(favorites)
 
+favorite_route_parser = reqparse.RequestParser()
+favorite_route_parser.add_argument('user_id', required=False, type=str)
+favorite_route_parser.add_argument('limit', required=False, type=int)
+favorite_route_parser.add_argument('offset', required=False, type=int)
+favorites_response = make_response("favorites_response", ns, fields.List(fields.Nested(activity_model_full)))
+@full_ns.route("/<string:user_id>/favorites/tracks")
+class FavoritedTracks(Resource):
+    @record_metrics
+    @full_ns.doc(
+        id="""Get User's Favorite Tracks""",
+        params={'user_id': 'A User ID'},
+        responses={
+            200: 'Success',
+            400: 'Bad request',
+            500: 'Server error'
+        }
+    )
+    @full_ns.expect(favorite_route_parser)
+    @full_ns.marshal_with(favorites_response)
+    @cache(ttl_sec=5)
+    def get(self, user_id):
+        """Fetch favorited tracks for a user."""
+        args = favorite_route_parser.parse_args()
+        decoded_id = decode_with_abort(user_id, ns)
+        current_user_id = None
+        if args.get("user_id"):
+            current_user_id = decode_string_id(user_id)
+
+        offset = format_offset(args)
+        limit = format_limit(args)
+        get_tracks_args = {
+            "filter_deleted": False,
+            "user_id": decoded_id,
+            "current_user_id": current_user_id,
+            "limit": limit,
+            "offset": offset,
+            "with_users": True
+        }
+        track_saves = get_save_tracks(get_tracks_args)
+        tracks = list(map(extend_activity, track_saves))
+        return success_response(tracks)
+
 user_search_result = make_response("user_search", ns, fields.List(fields.Nested(user_model)))
 
 @ns.route("/search")

discovery-provider/src/queries/get_save_tracks.py

@@ -0,0 +1,58 @@
+from src.models import Track, Save, SaveType
+from src.utils import helpers
+from src.utils.db_session import get_db_read_replica
+from src.queries import response_name_constants
+from src.queries.query_helpers import add_query_pagination, populate_track_metadata, \
+    get_users_by_id, get_users_ids
+
+def get_save_tracks(args):
+    user_id = args.get('user_id')
+    current_user_id = args.get('current_user_id')
+    limit = args.get('limit')
+    offset = args.get('offset')
+    filter_deleted = args.get("filter_deleted")
+
+    db = get_db_read_replica()
+    with db.scoped_session() as session:
+        base_query = (
+            session.query(Track, Save.created_at)
+            .join(Save, Save.save_item_id == Track.track_id)
+            .filter(
+                Track.is_current == True,
+                Save.user_id == user_id,
+                Save.is_current == True,
+                Save.is_delete == False,
+                Save.save_type == SaveType.track
+            )
+        )
+
+        # Allow filtering of deletes
+        if filter_deleted:
+            base_query = base_query.filter(
+                Track.is_delete == False
+            )
+
+        base_query = base_query.order_by(
+            Save.created_at.desc(), Track.track_id.desc())
+
+        query_results = add_query_pagination(base_query, limit, offset).all()
+        tracks, save_dates = zip(*query_results)
+        tracks = helpers.query_result_to_list(tracks)
+        track_ids = list(map(lambda track: track["track_id"], tracks))
+
+        # bundle peripheral info into track results
+        tracks = populate_track_metadata(
+            session, track_ids, tracks, current_user_id)
+
+        if args.get("with_users", False):
+            user_id_list = get_users_ids(tracks)
+            users = get_users_by_id(session, user_id_list, current_user_id)
+            for track in tracks:
+                user = users[track['owner_id']]
+                if user:
+                    track['user'] = user
+
+        for idx, track in enumerate(tracks):
+            track[response_name_constants.activity_timestamp] = save_dates[idx]
+
+        return tracks

discovery-provider/src/queries/get_savers_for_playlist.py

@@ -70,7 +70,7 @@ def get_savers_for_playlist(args):
         # Fix format to return only Users objects with follower_count field.
         if user_results:
             users, _ = zip(*user_results)
-            user_results = helpers.query_result_to_list(user_results)
+            user_results = helpers.query_result_to_list(users)
             # bundle peripheral info into user results
             user_ids = [user['user_id'] for user in user_results]
             user_results = populate_user_metadata(