def get(self, pk_or_uri):
""" Returns a single track object by primary key, if the track does
not exist a 404 will be returned.
Arguments
---------
pk : str
The track primary key
"""
try:
uuid.UUID(pk_or_uri, version=4)
except ValueError:
field = Track.spotify_uri
else:
field = Track.id
track = Track.query.filter(field == pk_or_uri).first()
if track is None:
return http.NotFound()
data = TrackSerializer().serialize(track)
data['audio_summary'] = track.audio_summary
return http.OK(data)
def get(self, *args, **kwargs):
""" Returns a paginated list of tracks currently in the playlist.
"""
offset = kwargs.pop('offset')
limit = kwargs.pop('limit')
queue = redis.lrange(config.PLAYLIST_REDIS_KEY, offset,
(offset + limit - 1))
total = redis.llen(config.PLAYLIST_REDIS_KEY)
response = []
if total > 0:
for item in queue:
item = json.loads(item)
track = Track.query.filter(
Track.spotify_uri == item['uri']).first()
user = User.query.filter(User.id == item['user']).first()
if track is not None and user is not None:
response.append({
'track': TrackSerializer().serialize(track),
'user': UserSerializer().serialize(user),
'uuid': item.get('uuid', None),
})
return http.OK(response,
page=kwargs.get('page'),
total=total,
limit=limit)
def get(self):
""" Returns the currently playing track.
Returns
-------
http.Response
A http response instance, 204 or 200
"""
track, user = self.get_current_track()
if track is None or user is None:
return http.NoContent()
# Get Pause State
try:
paused = int(redis.get('fm:player:paused'))
except (ValueError, TypeError):
paused = 0
elapsed = self.elapsed(paused=bool(paused))
headers = {'Paused': paused}
response = {
'track': TrackSerializer().serialize(track),
'user': UserSerializer().serialize(user),
'player': {
'elapsed_time': elapsed, # ms
'elapsed_percentage': (elapsed / track.duration) * 100, # %
'elapsed_seconds': elapsed / 1000 # seconds
}
}
return http.OK(response, headers=headers)
def get(self):
"""
"""
return http.OK({
'message': 'Welcome to the thisissoon.fm API',
})
def delete(self):
""" Unapuses the player.
"""
event = {'event': 'resume'}
redis.publish(config.PLAYER_CHANNEL, json.dumps(event))
return http.OK(event)
def get(self):
""" Retrieve the current volume level for the physical player.
"""
try:
volume = int(redis.get('fm:player:volume'))
except (ValueError, TypeError):
volume = 0
return http.OK({'volume': volume})
def delete(self):
""" Set the player mute state to False.
"""
redis.publish(config.PLAYER_CHANNEL,
json.dumps({
'event': 'set_mute',
'mute': False
}))
return http.OK({'mute': self.is_mute()})
def get(self, *args, **kwargs):
queue = list(Queue.get_queue())
tracks = list(Queue.get_tracks())
return http.OK({
'total':
Queue.length(),
'genres':
Counter(g.name for g in self.get_list_of_genres(tracks)),
'users':
Counter(q['user'] for q in queue),
'play_time':
sum(track.duration for track in tracks)
})
def get(self, *args, **kwargs):
""" Returns a paginated list of tracks stored in our DB.
"""
total = Track.query.count()
rows = Track.query \
.limit(kwargs.get('limit')) \
.offset(kwargs.get('offset')) \
.all()
return http.OK(TrackSerializer().serialize(rows, many=True),
limit=kwargs.get('limit'),
page=kwargs.get('page'),
total=total)
def get(self, *args, **kwargs):
""" Returns a paginated play list history.
"""
total = PlaylistHistory.query.count()
rows = db.session.query(PlaylistHistory) \
.order_by(desc(PlaylistHistory.created)) \
.limit(kwargs.get('limit')) \
.offset(kwargs.get('offset')) \
.all()
return http.OK(HistorySerializer().serialize(rows, many=True),
limit=kwargs.get('limit'),
page=kwargs.get('page'),
total=total)
def get(self, user_pk):
""" Get user's playlists.
If user is not authorized its Spotify account view returns HTTP code
for NO CONTENT
Arguments
---------
user_pk: str
The user primary key UUID
"""
user = User.query.get(user_pk)
if user.spotify_id is None:
return http.NoContent('User hasn\'t authorized Spotify account')
update_spotify_credentials(user)
spotify_api = SpotifyApi(user)
return http.OK(PlaylistSerializer().serialize(
[pl for pl in spotify_api.playlist_iterator()], many=True))
def post(self):
""" Change the volume level for the player.
"""
serializer = VolumeSerializer()
try:
data = serializer.marshal(request.json)
except MappingErrors as e:
return http.UnprocessableEntity(errors=e.message)
redis.publish(
config.PLAYER_CHANNEL,
json.dumps({
'event': 'set_volume',
'volume': data['volume']
}))
return http.OK(data)
def get(self, pk):
""" Get a serialized user object.
Arguments
---------
pk : str
The user primary key UUID
"""
try:
uuid.UUID(pk, version=4)
except ValueError:
user = None
else:
user = User.query.get(pk)
if user is None:
return http.NotFound()
return http.OK(UserSerializer().serialize(user))
def get(self, id=None):
"""Returns the artist data from spotify
"""
if id is None:
return http.NotFound()
# TODO: exception handling
token = get_client_credentials()
r = requests.get(
'https://api.spotify.com/v1/artists/{0}'.format(id),
headers={
"Authorization": "Bearer {0}".format(token),
})
if r.status_code != httplib.OK:
return http.NotFound()
return http.OK(r.json())
def get(self, user_pk, playlist_pk):
""" Get user's track in particular playlist.
If user is not authorized its Spotify account view returns HTTP code
for NO CONTENT
Arguments
---------
user_pk: str
The user primary key UUID
playlist_pk: str
The playlist spotify id
"""
user = User.query.get(user_pk)
if user.spotify_id is None:
return http.NoContent('User hasn\'t authorized Spotify account')
update_spotify_credentials(user)
spotify_api = SpotifyApi(user)
return http.OK(TrackSerializer().serialize(
[pl for pl in spotify_api.get_playlists_tracks(playlist_pk)],
many=True))
def get(self, id=None):
"""Returns an albums tracks
"""
if id is None:
return http.NotFound()
# TODO: exception handling
token = get_client_credentials()
r = requests.get(
'https://api.spotify.com/v1/albums/{0}/tracks'.format(id),
headers={
"Authorization": "Bearer {0}".format(token),
},
params=request.args)
if r.status_code != httplib.OK:
return http.NotFound()
return http.OK(r.json())
def get(self, pk):
try:
uuid.UUID(pk, version=4)
except ValueError:
user = None
else:
user = User.query.get(pk)
if user is None:
return http.NotFound()
since = request.args.get('from', None)
if since:
since = pytz.utc.localize(datetime.strptime(since, '%Y-%m-%d'))
until = request.args.get('to', None)
if until:
until = pytz.utc.localize(datetime.strptime(until, '%Y-%m-%d'))
payload = {
'most_played_tracks': [{
'track': FMTrackSerializer().serialize(u),
'total': t
} for u, t in self.most_played_tracks(pk, since, until)],
'most_played_artists': [{
'artist': ArtistSerializer().serialize(u),
'total': t
} for u, t in self.most_played_artists(pk, since, until)],
'most_played_genres': [{
'name': u.name,
'total': t
} for u, t in self.most_played_genres(pk, since, until)],
'total_plays':
self.total_plays(pk, since, until),
'total_play_time':
self.total_play_time(pk, since, until),
}
return http.OK(payload)
def get(self):
"""Implements the search endpoint via the Spotify Web API
which requires authentication
"""
# TODO: exception handling
token = get_client_credentials()
r = requests.get(
'https://api.spotify.com/v1/search',
headers={
"Authorization": "Bearer {0}".format(token),
},
params={
'q': request.args.get('q'),
'type': request.args.get('type'),
'market': request.args.get('market'),
'limit': request.args.get('limit'),
'offset': request.args.get('offset'),
})
return http.OK(r.json())
def get(self, *args, **kwargs):
since = request.args.get('from', None)
if since:
since = pytz.utc.localize(datetime.strptime(since, '%Y-%m-%d'))
until = request.args.get('to', None)
if until:
until = pytz.utc.localize(datetime.strptime(until, '%Y-%m-%d'))
payload = {
'most_active_djs': [{
'user': UserSerializer().serialize(u),
'total': t
} for u, t in stats.most_active_djs(since, until).limit(10)],
'most_played_tracks': [{
'track': TrackSerializer().serialize(u),
'total': t
} for u, t in stats.most_played_tracks(since, until).limit(10)],
'most_played_artists': [{
'artist': ArtistSerializer().serialize(u),
'total': t
} for u, t in stats.most_played_artists(since, until).limit(10)],
'most_played_genres': [{
'name': u.name,
'total': t
} for u, t in stats.most_played_genres(since, until).limit(10)],
'total_play_time_per_user':
[{
'user': UserSerializer().serialize(u),
'total': t
}
for u, t in stats.total_play_time_per_user(since, until).limit(10)
],
'total_play_time':
stats.total_play_time(since, until).first()[0],
'total_plays':
stats.total_plays(since, until).count(),
}
return http.OK(payload)
def delete(self):
""" Skips the currently playing track.
Returns
-------
http.Response
A http response intance, in this case it should always be a 204
"""
track, user = self.get_current_track()
if track is None or user is None:
return http.NoContent()
redis.publish(
config.PLAYER_CHANNEL,
json.dumps({
'event': 'stop',
'user': str(user.id),
'track': str(track.id),
'uri': str(track.spotify_uri),
'by': str(current_user.id),
}))
return http.OK()
def get(self):
""" Returns the current mute state of the player
"""
return http.OK({'mute': self.is_mute()})
def get(self):
""" Returns the currently authenticated user
"""
return http.OK(UserSerializer().serialize(current_user))
def delete(self, uuid):
try:
Queue.delete(uuid=uuid)
except ValueError:
return http.NoContent()
return http.OK()
