Fix changes to search for deleted (#902)

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

@@ -1,8 +1,8 @@
 import logging  # pylint: disable=C0302
 from flask_restx import Resource, Namespace, fields, reqparse
-from src.api.v1.helpers import extend_track, make_response, get_default_max, \
+from src.api.v1.helpers import extend_track, make_response, \
     success_response, format_offset, format_limit, decode_string_id, \
-    extend_user, extend_track, extend_playlist
+    extend_user, extend_track, extend_playlist, get_current_user_id
 from src.queries.search_queries import SearchKind, search
 from src.utils.redis_cache import cache, extract_key, use_redis_cache
 from src.utils.redis_metrics import record_metrics
@@ -64,12 +64,10 @@ class FullSearch(Resource):
     @cache(ttl_sec=5)
     def get(self):
         args = search_route_parser.parse_args()
-        limit = get_default_max(args.get('limit'), 10, 100)
-        offset = get_default_max(args.get('offset'), 0)
+        offset = format_offset(args)
+        limit = format_limit(args)
+        current_user_id = get_current_user_id(args)
 
-        current_user_id = None
-        if args.get("user_id"):
-            current_user_id = decode_string_id(args["user_id"])
         search_args = {
           "is_auto_complete": False,
           "kind": args.get("kind", "all"),
@@ -108,12 +106,10 @@ class FullSearch(Resource):
     @cache(ttl_sec=5)
     def get(self):
         args = search_route_parser.parse_args()
-        limit = get_default_max(args.get('limit'), 10, 100)
-        offset = get_default_max(args.get('offset'), 0)
+        offset = format_offset(args)
+        limit = format_limit(args)
+        current_user_id = get_current_user_id(args)
 
-        current_user_id = None
-        if args.get("user_id"):
-            current_user_id = decode_string_id(args["user_id"])
         search_args = {
           "is_auto_complete": True,
           "kind": args.get("kind", "all"),

discovery-provider/src/queries/get_unpopulated_playlists.py

@@ -27,7 +27,7 @@ def set_playlists_in_cache(playlists):
         redis.set(key, serialized, ttl_sec)
 
 
-def get_unpopulated_playlists(session, playlist_ids):
+def get_unpopulated_playlists(session, playlist_ids, filter_deleted=False):
     """
     Fetches playlists by checking the redis cache first then
     going to DB and writes to cache if not present
@@ -43,26 +43,29 @@ def get_unpopulated_playlists(session, playlist_ids):
     cached_playlists_results = get_cached_playlists(playlist_ids)
     has_all_playlists_cached = cached_playlists_results.count(None) == 0
     if has_all_playlists_cached:
+        if filter_deleted:
+            return list(filter(lambda playlist: not playlist['is_delete'], cached_playlists_results))
         return cached_playlists_results
 
     # Create a dict of cached playlists
     cached_playlists = {}
-    cached_playlist_ids = set()
     for cached_playlist in cached_playlists_results:
         if cached_playlist:
             cached_playlists[cached_playlist['playlist_id']] = cached_playlist
-            cached_playlist_ids.add(cached_playlist['playlist_id'])
 
     playlist_ids_to_fetch = filter(
-        lambda playlist_id: playlist_id not in cached_playlist_ids, playlist_ids)
+        lambda playlist_id: playlist_id not in cached_playlists, playlist_ids)
 
-    playlists = (
+    playlists_query = (
         session
         .query(Playlist)
         .filter(Playlist.is_current == True)
         .filter(Playlist.playlist_id.in_(playlist_ids_to_fetch))
-        .all()
     )
+    if filter_deleted:
+        playlists_query = playlists_query.filter(Playlist.is_delete == False)
+
+    playlists = playlists_query.all()
     playlists = helpers.query_result_to_list(playlists)
     queried_playlists = {playlist['playlist_id']: playlist for playlist in playlists}
 
@@ -72,7 +75,8 @@ def get_unpopulated_playlists(session, playlist_ids):
     playlists_response = []
     for playlist_id in playlist_ids:
         if playlist_id in cached_playlists:
-            playlists_response.append(cached_playlists[playlist_id])
+            if not filter_deleted or not cached_playlists[playlist_id]['is_delete']:
+                playlists_response.append(cached_playlists[playlist_id])
         elif playlist_id in queried_playlists:
             playlists_response.append(queried_playlists[playlist_id])
 

discovery-provider/src/queries/get_unpopulated_tracks.py

@@ -27,7 +27,7 @@ def set_tracks_in_cache(tracks):
         redis.set(key, serialized, ttl_sec)
 
 
-def get_unpopulated_tracks(session, track_ids):
+def get_unpopulated_tracks(session, track_ids, filter_deleted=False):
     """
     Fetches tracks by checking the redis cache first then
     going to DB and writes to cache if not present
@@ -43,25 +43,29 @@ def get_unpopulated_tracks(session, track_ids):
     cached_tracks_results = get_cached_tracks(track_ids)
     has_all_tracks_cached = cached_tracks_results.count(None) == 0
     if has_all_tracks_cached:
+        if filter_deleted:
+            return list(filter(lambda track: not track['is_delete'], cached_tracks_results))
         return cached_tracks_results
 
     # Create a dict of cached tracks
     cached_tracks = {}
-    cached_track_ids = set()
     for cached_track in cached_tracks_results:
         if cached_track:
             cached_tracks[cached_track['track_id']] = cached_track
-            cached_track_ids.add(cached_track['track_id'])
 
     track_ids_to_fetch = filter(
-        lambda track_id: track_id not in cached_track_ids, track_ids)
+        lambda track_id: track_id not in cached_tracks, track_ids)
 
-    tracks = (
+    tracks_query = (
         session.query(Track)
         .filter(Track.is_current == True, Track.is_unlisted == False, Track.stem_of == None)
         .filter(Track.track_id.in_(track_ids_to_fetch))
-        .all()
     )
+
+    if filter_deleted:
+        tracks_query = tracks_query.filter(Track.is_delete == False)
+
+    tracks = tracks_query.all()
     tracks = helpers.query_result_to_list(tracks)
     queried_tracks = {track['track_id']: track for track in tracks}
 
@@ -71,7 +75,8 @@ def get_unpopulated_tracks(session, track_ids):
     tracks_response = []
     for track_id in track_ids:
         if track_id in cached_tracks:
-            tracks_response.append(cached_tracks[track_id])
+            if not filter_deleted or not cached_tracks[track_id]['is_delete']:
+                tracks_response.append(cached_tracks[track_id])
         elif track_id in queried_tracks:
             tracks_response.append(queried_tracks[track_id])
 

discovery-provider/src/queries/get_unpopulated_users.py

@@ -45,14 +45,12 @@ def get_unpopulated_users(session, user_ids):
         return cached_users_results
 
     cached_users = {}
-    cached_user_ids = set()
     for cached_user in cached_users_results:
         if cached_user:
             cached_users[cached_user['user_id']] = cached_user
-            cached_user_ids.add(cached_user['user_id'])
 
     user_ids_to_fetch = filter(
-        lambda user_id: user_id not in cached_user_ids, user_ids)
+        lambda user_id: user_id not in cached_users, user_ids)
 
     users = (
         session

discovery-provider/src/queries/search_queries.py

@@ -465,7 +465,7 @@ def track_search_query(
 
     # track_ids is list of tuples - simplify to 1-D list
     track_ids = [i[0] for i in track_ids]
-    tracks = get_unpopulated_tracks(session, track_ids)
+    tracks = get_unpopulated_tracks(session, track_ids, True)
 
     if is_auto_complete == True:
         # fetch users for tracks
@@ -482,7 +482,7 @@ def track_search_query(
             session, track_ids, tracks, current_user_id)
 
     # preserve order from track_ids above
-    tracks = [next(t for t in tracks if t["track_id"] == track_id)
+    tracks = [next((t for t in tracks if t["track_id"] == track_id), None)
               for track_id in track_ids]
     return tracks
 
@@ -603,12 +603,11 @@ def playlist_search_query(session, searchStr, limit, offset, is_album, personali
 
     # playlist_ids is list of tuples - simplify to 1-D list
     playlist_ids = [i[0] for i in playlist_ids]
-    playlists = get_unpopulated_playlists(session, playlist_ids)
+    playlists = get_unpopulated_playlists(session, playlist_ids, True)
 
-    if is_auto_complete == True:
+    if is_auto_complete:
         # fetch users for playlists
-        playlist_owner_ids = list(
-            map(lambda playlist: playlist["playlist_owner_id"], playlists))
+        playlist_owner_ids = list(map(lambda playlist: playlist["playlist_owner_id"], playlists))
         users = get_unpopulated_users(session, playlist_owner_ids)
         users_dict = {user["user_id"]: user for user in users}
 
@@ -627,6 +626,6 @@ def playlist_search_query(session, searchStr, limit, offset, is_album, personali
         )
 
     # preserve order from playlist_ids above
-    playlists = [next(p for p in playlists if p["playlist_id"]
-                      == playlist_id) for playlist_id in playlist_ids]
+    playlists = [next((p for p in playlists if p["playlist_id"]
+                       == playlist_id), None) for playlist_id in playlist_ids]
     return playlists