make_response, success_response, search_parser, abort_bad_request_param, decode_string_id, \
extend_user, get_default_max, get_current_user_id
from .models.tracks import track
from src.queries.search_queries import SearchKind, search
from src.utils.redis_cache import cache
from src.utils.redis_metrics import record_metrics
from src.queries.get_reposters_for_playlist import get_reposters_for_playlist
from src.queries.get_savers_for_playlist import get_savers_for_playlist
logger = logging.getLogger(__name__)
ns = Namespace('playlists', description='Playlist related operations')
full_ns = Namespace('playlists', description='Full playlist related operations')
playlists_response = make_response("playlist_response", ns, fields.List(fields.Nested(playlist_model)))
full_playlists_response = make_full_response("full_playlist_response", full_ns, fields.List(fields.Nested(full_playlist_model)))
def get_playlist(playlist_id, current_user_id):
"""Returns a single playlist, or None"""
args = {
"playlist_id": [playlist_id],
"with_users": True,
"current_user_id": current_user_id
}
playlists = get_playlists(args)
if playlists:
return extend_playlist(playlists[0])
return None
def get_tracks_for_playlist(playlist_id, current_user_id=None):
args = {"playlist_id": playlist_id, "with_users": True, "current_user_id": current_user_id}
from src.queries.get_tracks_including_unlisted import get_tracks_including_unlisted
from src.queries.get_stems_of import get_stems_of
from src.queries.get_remixes_of import get_remixes_of
from src.queries.get_remix_track_parents import get_remix_track_parents
from src.queries.get_trending_ids import get_trending_ids
from src.queries.get_trending import TRENDING_LIMIT, TRENDING_TTL_SEC, get_trending
logger = logging.getLogger(__name__)
# Models & namespaces
ns = Namespace('tracks', description='Track related operations')
full_ns = Namespace('tracks', description='Full track operations')
track_response = make_response("track_response", ns, fields.Nested(track))
full_track_response = make_full_response("full_track_response", full_ns,
fields.Nested(track_full))
tracks_response = make_response("tracks_response", ns,
fields.List(fields.Nested(track)))
full_tracks_response = make_full_response(
"full_tracks_response", full_ns, fields.List(fields.Nested(track_full)))
# Get single track
def get_single_track(track_id, current_user_id, endpoint_ns):
args = {
"id": [track_id],
"with_users": True,
"filter_deleted": True,
"current_user_id": current_user_id
from src.api.v1.helpers import abort_not_found, decode_with_abort, extend_activity, extend_favorite, extend_track, \
extend_user, format_limit, format_offset, get_current_user_id, make_full_response, make_response, search_parser, success_response, abort_bad_request_param, \
get_default_max, encode_int_id
from .models.tracks import track, track_full
from .models.activities import activity_model, activity_model_full
from src.utils.redis_cache import cache
from src.utils.redis_metrics import record_metrics
from src.queries.get_top_genre_users import get_top_genre_users
logger = logging.getLogger(__name__)
ns = Namespace('users', description='User related operations')
full_ns = Namespace('users', description='Full user operations')
user_response = make_response("user_response", ns, fields.Nested(user_model))
full_user_response = make_full_response(
"full_user_response", full_ns, fields.List(fields.Nested(user_model_full)))
def get_single_user(user_id, current_user_id):
args = {"id": [user_id], "current_user_id": current_user_id}
users = get_users(args)
if not users:
abort_not_found(user_id, ns)
user = extend_user(users[0])
return success_response(user)
USER_ROUTE = "/<string:user_id>"
@ns.route(USER_ROUTE)
if 'saved_playlists' in resp:
resp['saved_playlists'] = list(map(extend_playlist, resp['saved_playlists']))
if 'albums' in resp:
resp['albums'] = list(map(extend_playlist, resp['albums']))
if 'saved_albums' in resp:
resp['saved_albums'] = list(map(extend_playlist, resp['saved_albums']))
return resp
search_route_parser = reqparse.RequestParser()
search_route_parser.add_argument('user_id', required=False)
search_route_parser.add_argument(
'kind', required=False, type=str, default='all', choices=('all', 'users', 'tracks', 'playlists', 'albums'))
search_route_parser.add_argument('query', required=True, type=str)
search_route_parser.add_argument('limit', required=False, type=int)
search_route_parser.add_argument('offset', required=False, type=int)
search_full_response = make_full_response("search_full_response", full_ns, fields.Nested(search_model))
@full_ns.route("/full")
class FullSearch(Resource):
@full_ns.expect(search_route_parser)
@full_ns.doc(
id="""Get Users/Tracks/Playlists/Albums that best match the search query""",
params={
'user_id': 'A User ID of the requesting user to personalize the response',
'query': 'Search query text',
'kind': 'The type of response, one of: all, users, tracks, playlists, or albums',
'limit': 'Limit',
'offset': 'Offset'
},
responses={
200: 'Success',
400: 'Bad request',
from src.utils.db_session import get_db_read_replica
from src.utils.helpers import encode_int_id
from src.utils.redis_cache import cache
from src.utils.redis_metrics import record_metrics
from .models.activities import activity_model, activity_model_full
from .models.tracks import track, track_full
logger = logging.getLogger(__name__)
ns = Namespace("users", description="User related operations")
full_ns = Namespace("users", description="Full user operations")
user_response = make_response("user_response", ns, fields.Nested(user_model))
full_user_response = make_full_response(
"full_user_response", full_ns, fields.List(fields.Nested(user_model_full))
)
def get_single_user(user_id, current_user_id):
args = {"id": [user_id], "current_user_id": current_user_id}
users = get_users(args)
if not users:
abort_not_found(user_id, ns)
user = extend_user(users[0], current_user_id)
return success_response(user)
USER_ROUTE = "/<string:id>"
