def test_load(self): token = Token.generate(self.user.api_key) self.assertIsInstance(token, Token) self.assertIsNone(token.user) """ Before approving """ # Load with token token1 = Token.load(token.token) self.assertIsNone(token1.user) self.assertDictEqual(token1.__dict__, token.__dict__) # Load with token & api_key token2 = Token.load(token.token, token.api_key) self.assertIsNone(token2.user) self.assertDictEqual(token2.__dict__, token.__dict__) token.approve(self.user.name) """ After approving the token """ # Load with token token1 = Token.load(token.token) self.assertIsInstance(token1.user, User) self.assertDictEqual(token1.user.__dict__, token.user.__dict__) token_user = token.user token.user, token1.user = None, None self.assertDictEqual(token1.__dict__, token.__dict__) token.user = token_user # Load with token & api_key token2 = Token.load(token.token, token.api_key) self.assertIsInstance(token2.user, User) self.assertDictEqual(token2.user.__dict__, token.user.__dict__) token.user, token1.user = None, None self.assertDictEqual(token1.__dict__, token.__dict__)
def test_load(self): token = Token.generate(self.user.api_key) self.assertIsInstance(token, Token) self.assertIsNone(token.user) """ Before approving """ # Load with token token1 = Token.load(token.token) self.assertIsNone(token1.user) self.assertDictEqual(token1.__dict__, token.__dict__) # Load with token & api_key token2 = Token.load(token.token, token.api_key) self.assertIsNone(token2.user) self.assertDictEqual(token2.__dict__, token.__dict__) token.approve(self.user.name) """ After approving the token """ # Load with token token1 = Token.load(token.token) self.assertIsInstance(token1.user, User) self.assertDictEqual(token1.user.__dict__, token.user.__dict__) token_user = token.user token.user, token1.user = None, None self.assertDictEqual(token1.__dict__, token.__dict__) token.user = token_user # Load with token & api_key token2 = Token.load(token.token, token.api_key) self.assertIsInstance(token2.user, User) self.assertDictEqual(token2.user.__dict__, token.user.__dict__) token.user, token1.user = None, None self.assertDictEqual(token1.__dict__, token.__dict__)
def get_session(request, data): """ Create new session after validating the API_key and token. """ output_format = data.get('format', 'xml') try: api_key = data['api_key'] token = Token.load(data['token'], api_key) except KeyError: raise InvalidAPIUsage(CompatError.INVALID_PARAMETERS, output_format=output_format) # Missing Required Params if not token: if not Token.is_valid_api_key(api_key): raise InvalidAPIUsage(CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API_key raise InvalidAPIUsage(CompatError.INVALID_TOKEN, output_format=output_format) # Invalid token if token.has_expired(): raise InvalidAPIUsage(CompatError.TOKEN_EXPIRED, output_format=output_format) # Token expired if not token.user: raise InvalidAPIUsage(CompatError.UNAUTHORIZED_TOKEN, output_format=output_format) # Unauthorized token session = Session.create(token) doc, tag, text = Doc().tagtext() with tag('lfm', status='ok'): with tag('session'): with tag('name'): text(session.user.name) with tag('key'): text(session.sid) with tag('subscriber'): text('0') return format_response('<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()), data.get('format', "xml"))
def test_record_listen(self): """ Tests if listen is recorded correctly if valid information is provided. """ token = Token.generate(self.lfm_user.api_key) token.approve(self.lfm_user.name) session = Session.create(token) timestamp = int(time.time()) data = { 'method': 'track.scrobble', 'api_key': self.lfm_user.api_key, 'sk': session.sid, 'artist[0]': 'Kishore Kumar', 'track[0]': 'Saamne Ye Kaun Aya', 'album[0]': 'Jawani Diwani', 'duration[0]': 300, 'timestamp[0]': timestamp, } r = self.client.post(url_for('api_compat.api_methods'), data=data) self.assert200(r) response = xmltodict.parse(r.data) self.assertEqual(response['lfm']['@status'], 'ok') self.assertEqual(response['lfm']['scrobbles']['@accepted'], '1') # Check if listen reached the influx listenstore time.sleep(1) listens = self.ls.fetch_listens(self.lb_user['musicbrainz_id'], from_ts=timestamp-1) self.assertEqual(len(listens), 1)
def test_record_listen_now_playing(self): """ Tests if listen of type 'nowplaying' is recorded correctly if valid information is provided. """ token = Token.generate(self.lfm_user.api_key) token.approve(self.lfm_user.name) session = Session.create(token) data = { 'method': 'track.updateNowPlaying', 'api_key': self.lfm_user.api_key, 'sk': session.sid, 'artist[0]': 'Kishore Kumar', 'track[0]': 'Saamne Ye Kaun Aya', 'album[0]': 'Jawani Diwani', 'duration[0]': 300, 'timestamp[0]': int(time.time()), } r = self.client.post(url_for('api_compat.api_methods'), data=data) self.assert200(r) response = xmltodict.parse(r.data) self.assertEqual(response['lfm']['@status'], 'ok') self.assertIsNotNone(response['lfm']['nowplaying'])
def test_record_listen(self): """ Tests if listen is recorded correctly if valid information is provided. """ token = Token.generate(self.lfm_user.api_key) token.approve(self.lfm_user.name) session = Session.create(token) timestamp = int(time.time()) data = { 'method': 'track.scrobble', 'api_key': self.lfm_user.api_key, 'sk': session.sid, 'artist[0]': 'Kishore Kumar', 'track[0]': 'Saamne Ye Kaun Aya', 'album[0]': 'Jawani Diwani', 'duration[0]': 300, 'timestamp[0]': timestamp, } r = self.client.post(url_for('api_compat.api_methods'), data=data) self.assert200(r) response = xmltodict.parse(r.data) self.assertEqual(response['lfm']['@status'], 'ok') self.assertEqual(response['lfm']['scrobbles']['@accepted'], '1') # Check if listen reached the timescale listenstore time.sleep(2) listens, _, _ = self.ls.fetch_listens(self.lb_user['musicbrainz_id'], from_ts=timestamp - 1) self.assertEqual(len(listens), 1)
def api_auth_approve(): """ Authenticate the user token provided. """ user = User.load_by_name(current_user.musicbrainz_id) if "token" not in request.form: return render_template( "user/auth.html", user_id=current_user.musicbrainz_id, msg="Missing required parameters. Please provide correct parameters and try again." ) token = Token.load(request.form['token']) if not token: return render_template( "user/auth.html", user_id=current_user.musicbrainz_id, msg="Either this token is already used or invalid. Please try again." ) if token.user: return render_template( "user/auth.html", user_id=current_user.musicbrainz_id, msg="This token is already approved. Please check the token and try again." ) if token.has_expired(): return render_template( "user/auth.html", user_id=current_user.musicbrainz_id, msg="This token has expired. Please create a new token and try again." ) token.approve(user.name) return render_template( "user/auth.html", user_id=current_user.musicbrainz_id, msg="Token %s approved for user %s, press continue in client." % (token.token, current_user.musicbrainz_id) )
def test_session_create(self): user = User.load_by_id(db_user.create(1, "test")) token = Token.generate(user.api_key) token.approve(user.name) session = Session.create(token) self.assertIsInstance(session, Session) self.assertDictEqual(user.__dict__, session.user.__dict__)
def test_session_create(self): user = User.load_by_id(db_user.create("test")) token = Token.generate(user.api_key) token.approve(user.name) session = Session.create(token) self.assertIsInstance(session, Session) self.assertDictEqual(user.__dict__, session.user.__dict__)
def test_record_listen_now_playing(self): """ Tests if listen of type 'nowplaying' is recorded correctly if valid information is provided. """ token = Token.generate(self.lfm_user.api_key) token.approve(self.lfm_user.name) session = Session.create(token) data = { 'method': 'track.updateNowPlaying', 'api_key': self.lfm_user.api_key, 'sk': session.sid, 'artist[0]': 'Kishore Kumar', 'track[0]': 'Saamne Ye Kaun Aya', 'album[0]': 'Jawani Diwani', 'duration[0]': 300, 'timestamp[0]': int(time.time()), } r = self.client.post(url_for('api_compat.api_methods'), data=data) self.assert200(r) response = xmltodict.parse(r.data) self.assertEqual(response['lfm']['@status'], 'ok') self.assertIsNotNone(response['lfm']['nowplaying'])
def test_user_getinfo_no_listenstore(self): """If this listenstore is unavailable, performing a query that gets user information (touches the listenstore for user count) should return an error message in the requested format""" timescale_connection._ts = None token = Token.generate(self.lfm_user.api_key) token.approve(self.lfm_user.name) session = Session.create(token) data = { 'method': 'user.getInfo', 'api_key': self.lfm_user.api_key, 'sk': session.sid } r = self.client.post(url_for('api_compat.api_methods'), data=data) self.assert200(r) self.assertEqual(r.headers["Content-type"], "application/xml; charset=utf-8") expected_message = b"""<?xml version="1.0" encoding="utf-8"?> <lfm status="failed"> <error code="16">The service is temporarily unavailable, please try again.</error> </lfm>""" assert r.data == expected_message
def test_has_expired(self): token = Token.generate(str(uuid.uuid4())) self.assertFalse(token.has_expired()) token.timestamp = token.timestamp - timedelta(minutes=TOKEN_EXPIRATION_TIME - 1) # This is asssertFalse because in the next 1 minute the next statement will get executed self.assertFalse(token.has_expired()) token.timestamp = token.timestamp - timedelta(minutes=1) self.assertTrue(token.has_expired())
def test_has_expired(self): token = Token.generate(str(uuid.uuid4())) self.assertFalse(token.has_expired()) token.timestamp = token.timestamp - timedelta( minutes=TOKEN_EXPIRATION_TIME - 1) # This is asssertFalse because in the next 1 minute the next statement will get executed self.assertFalse(token.has_expired()) token.timestamp = token.timestamp - timedelta(minutes=1) self.assertTrue(token.has_expired())
def get_token(request, data): """ Issue a token to user after verying his API_KEY """ output_format = data.get('format', 'xml') api_key = data.get('api_key') if not api_key: raise InvalidAPIUsage(CompatError.INVALID_PARAMETERS, output_format=output_format) # Missing required params if not Token.is_valid_api_key(api_key): raise InvalidAPIUsage(CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API_KEY token = Token.generate(api_key) doc, tag, text = Doc().tagtext() with tag('lfm', status='ok'): with tag('token'): text(token.token) return format_response('<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()), output_format)
def record_listens(request, data): """ Submit the listen in the lastfm format to be inserted in db. Accepts listens for both track.updateNowPlaying and track.scrobble methods. """ output_format = data.get('format', 'xml') try: sk, api_key = data['sk'], data['api_key'] except KeyError: raise InvalidAPIUsage(CompatError.INVALID_PARAMETERS, output_format=output_format) # Invalid parameters session = Session.load(sk) if not session: if not Token.is_valid_api_key(api_key): raise InvalidAPIUsage(CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API_KEY raise InvalidAPIUsage(CompatError.INVALID_SESSION_KEY, output_format=output_format) # Invalid Session KEY lookup = defaultdict(dict) for key, value in data.items(): if key in ["sk", "token", "api_key", "method", "api_sig"]: continue matches = re.match('(.*)\[(\d+)\]', key) if matches: key = matches.group(1) number = matches.group(2) else: number = 0 lookup[number][key] = value if request.form['method'].lower() == 'track.updatenowplaying': for i, listen in lookup.items(): if 'timestamp' not in listen: listen['timestamp'] = calendar.timegm(datetime.now().utctimetuple()) # Convert to native payload then submit 'em after validation. listen_type, native_payload = _to_native_api(lookup, data['method'], output_format) for listen in native_payload: validate_listen(listen, listen_type) user = db_user.get(session.user_id) augmented_listens = insert_payload(native_payload, user, listen_type=listen_type) # With corrections than the original submitted listen. doc, tag, text = Doc().tagtext() with tag('lfm', status='ok'): if listen_type == 'playing_now': doc.asis(create_response_for_single_listen(list(lookup.values())[0], augmented_listens[0], listen_type)) else: accepted_listens = len(lookup.values()) # Currently LB accepts all the listens and ignores none with tag('scrobbles', accepted=accepted_listens, ignored='0'): for original_listen, augmented_listen in zip(list(lookup.values()), augmented_listens): doc.asis(create_response_for_single_listen(original_listen, augmented_listen, listen_type)) return format_response('<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()), output_format)
def get_session(request, data): """ Create new session after validating the API_key and token. """ output_format = data.get('format', 'xml') try: api_key = data['api_key'] token = Token.load(data['token'], api_key) except KeyError: raise InvalidAPIUsage( CompatError.INVALID_PARAMETERS, output_format=output_format) # Missing Required Params if not token: if not Token.is_valid_api_key(api_key): raise InvalidAPIUsage( CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API_key raise InvalidAPIUsage(CompatError.INVALID_TOKEN, output_format=output_format) # Invalid token if token.has_expired(): raise InvalidAPIUsage(CompatError.TOKEN_EXPIRED, output_format=output_format) # Token expired if not token.user: raise InvalidAPIUsage( CompatError.UNAUTHORIZED_TOKEN, output_format=output_format) # Unauthorized token session = Session.create(token) doc, tag, text = Doc().tagtext() with tag('lfm', status='ok'): with tag('session'): with tag('name'): text(session.user.name) with tag('key'): text(session.sid) with tag('subscriber'): text('0') return format_response( '<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()), data.get('format', "xml"))
def user_info(request, data): """ Gives information about the user specified in the parameters. """ try: output_format = data.get('format', 'xml') api_key = data['api_key'] sk = data.get('sk') username = data.get('user') if not (sk or username): raise KeyError if not Token.is_valid_api_key(api_key): raise InvalidAPIUsage( CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API key user = User.load_by_sessionkey(sk, api_key) if not user: raise InvalidAPIUsage( CompatError.INVALID_SESSION_KEY, output_format=output_format) # Invalid Session key query_user = User.load_by_name(username) if ( username and username != user.name) else user if not query_user: raise InvalidAPIUsage( CompatError.INVALID_RESOURCE, output_format=output_format) # Invalid resource specified except KeyError: raise InvalidAPIUsage( CompatError.INVALID_PARAMETERS, output_format=output_format) # Missing required params doc, tag, text = Doc().tagtext() with tag('lfm', status='ok'): with tag('user'): with tag('name'): text(query_user.name) with tag('realname'): text(query_user.name) with tag('url'): text('http://listenbrainz.org/user/' + query_user.name) with tag('playcount'): text( User.get_play_count(query_user.id, timescale_connection._ts)) with tag('registered', unixtime=str(query_user.created.strftime("%s"))): text(str(query_user.created)) return format_response( '<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()), data.get('format', "xml"))
def test_session_load(self): user = User.load_by_id(db_user.create(1, "test")) token = Token.generate(user.api_key) token.approve(user.name) session = Session.create(token) self.assertIsInstance(session, Session) self.assertDictEqual(user.__dict__, session.user.__dict__) session.user = None # Load with session_key + api_key session2 = Session.load(session.sid) self.assertDictEqual(user.__dict__, session2.__dict__['user'].__dict__) session2.user = None self.assertDictEqual(session.__dict__, session2.__dict__)
def get_token(request, data): """ Issue a token to user after verying his API_KEY """ output_format = data.get('format', 'xml') api_key = data.get('api_key') if not api_key: raise InvalidAPIUsage( CompatError.INVALID_PARAMETERS, output_format=output_format) # Missing required params if not Token.is_valid_api_key(api_key): raise InvalidAPIUsage(CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API_KEY token = Token.generate(api_key) doc, tag, text = Doc().tagtext() with tag('lfm', status='ok'): with tag('token'): text(token.token) return format_response( '<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()), output_format)
def test_session_load(self): user = User.load_by_id(db_user.create("test")) token = Token.generate(user.api_key) token.approve(user.name) session = Session.create(token) self.assertIsInstance(session, Session) self.assertDictEqual(user.__dict__, session.user.__dict__) session.user = None # Load with session_key + api_key session2 = Session.load(session.sid, session.api_key) self.assertDictEqual(user.__dict__, session2.__dict__['user'].__dict__) session2.user = None self.assertDictEqual(session.__dict__, session2.__dict__)
def test_approve(self): token = Token.generate(str(uuid.uuid4())) self.assertIsInstance(token, Token) self.assertIsNone(token.user) before_token = token.__dict__ before_token.pop('user') token.approve(self.user.name) after_token = token.__dict__ self.assertIsInstance(token.user, User) self.assertDictEqual(token.user.__dict__, self.user.__dict__) after_token.pop('user') self.assertDictEqual(after_token, before_token)
def test_approve(self): token = Token.generate(str(uuid.uuid4())) self.assertIsInstance(token, Token) self.assertIsNone(token.user) before_token = token.__dict__ before_token.pop('user') token.approve(self.user.name) after_token = token.__dict__ self.assertIsInstance(token.user, User) self.assertDictEqual(token.user.__dict__, self.user.__dict__) after_token.pop('user') self.assertDictEqual(after_token, before_token)
def test_get_token(self): """ Tests if the token generated by get_token method is valid. """ data = { 'method': 'auth.gettoken', 'api_key': self.lfm_user.api_key, } r = self.client.post(url_for('api_compat.api_methods'), data=data) self.assert200(r) response = xmltodict.parse(r.data) self.assertEqual(response['lfm']['@status'], 'ok') token = Token.load(response['lfm']['token'], api_key=self.lfm_user.api_key) self.assertIsNotNone(token)
def test_get_token(self): """ Tests if the token generated by get_token method is valid. """ data = { 'method': 'auth.gettoken', 'api_key': self.lfm_user.api_key, } r = self.client.post(url_for('api_compat.api_methods'), data=data) self.assert200(r) response = xmltodict.parse(r.data) self.assertEqual(response['lfm']['@status'], 'ok') token = Token.load(response['lfm']['token'], api_key=self.lfm_user.api_key) self.assertIsNotNone(token)
def test_get_session(self): """ Tests if the session key is valid and session is established correctly. """ token = Token.generate(self.lfm_user.api_key) token.approve(self.lfm_user.name) data = { 'method': 'auth.getsession', 'api_key': self.lfm_user.api_key, 'token': token.token, } r = self.client.post(url_for('api_compat.api_methods'), data=data) self.assert200(r) response = xmltodict.parse(r.data) self.assertEqual(response['lfm']['@status'], 'ok') self.assertEqual(response['lfm']['session']['name'], self.lfm_user.name) session_key = Session.load(response['lfm']['session']['key']) self.assertIsNotNone(session_key)
def user_info(request, data): """ Gives information about the user specified in the parameters. """ try: api_key = data['api_key'] output_format = data.get('format', 'xml') sk = data.get('sk') username = data.get('user') if not (sk or username): raise KeyError if not Token.is_valid_api_key(api_key): raise InvalidAPIUsage(CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API key user = User.load_by_sessionkey(sk, api_key) if not user: raise InvalidAPIUsage(CompatError.INVALID_SESSION_KEY, output_format=output_format) # Invalid Session key query_user = User.load_by_name(username) if (username and username != user.name) else user if not query_user: raise InvalidAPIUsage(CompatError.INVALID_RESOURCE, output_format=output_format) # Invalid resource specified except KeyError: raise InvalidAPIUsage(CompatError.INVALID_PARAMETERS, output_format=output_format) # Missing required params doc, tag, text = Doc().tagtext() with tag('lfm', status='ok'): with tag('user'): with tag('name'): text(query_user.name) with tag('realname'): text(query_user.name) with tag('url'): text('http://listenbrainz.org/user/' + query_user.name) with tag('playcount'): text(User.get_play_count(query_user.id, _influx)) with tag('registered', unixtime=str(query_user.created.strftime("%s"))): text(str(query_user.created)) return format_response('<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()), data.get('format', "xml"))
def test_get_session(self): """ Tests if the session key is valid and session is established correctly. """ token = Token.generate(self.lfm_user.api_key) token.approve(self.lfm_user.name) data = { 'method': 'auth.getsession', 'api_key': self.lfm_user.api_key, 'token': token.token, } r = self.client.post(url_for('api_compat.api_methods'), data=data) self.assert200(r) response = xmltodict.parse(r.data) self.assertEqual(response['lfm']['@status'], 'ok') self.assertEqual(response['lfm']['session']['name'], self.lfm_user.name) session_key = Session.load(response['lfm']['session']['key']) self.assertIsNotNone(session_key)
def test_record_invalid_listen(self): """ Tests that error is raised if submited data contains unicode null """ token = Token.generate(self.lfm_user.api_key) token.approve(self.lfm_user.name) session = Session.create(token) timestamp = int(time.time()) data = { 'method': 'track.scrobble', 'api_key': self.lfm_user.api_key, 'sk': session.sid, 'artist[0]': '\u0000Kishore Kumar', 'track[0]': 'Saamne Ye Kaun Aya', 'album[0]': 'Jawani Diwani', 'duration[0]': 300, 'timestamp[0]': timestamp, } r = self.client.post(url_for('api_compat.api_methods'), data=data) self.assert400(r) self.assertEqual(r.json["error"], "\u0000Kishore Kumar contains a unicode null")
def api_auth_approve(): """ Authenticate the user token provided. """ user = User.load_by_name(current_user.musicbrainz_id) if "token" not in request.form: return render_template( "user/auth.html", user_id=current_user.musicbrainz_id, msg= "Missing required parameters. Please provide correct parameters and try again." ) token = Token.load(request.form['token']) if not token: return render_template( "user/auth.html", user_id=current_user.musicbrainz_id, msg= "Either this token is already used or invalid. Please try again.") if token.user: return render_template( "user/auth.html", user_id=current_user.musicbrainz_id, msg= "This token is already approved. Please check the token and try again." ) if token.has_expired(): return render_template( "user/auth.html", user_id=current_user.musicbrainz_id, msg= "This token has expired. Please create a new token and try again.") token.approve(user.name) return render_template( "user/auth.html", user_id=current_user.musicbrainz_id, msg="Token %s approved for user %s, press continue in client." % (token.token, current_user.musicbrainz_id))
def record_listens(data): """ Submit the listen in the lastfm format to be inserted in db. Accepts listens for both track.updateNowPlaying and track.scrobble methods. """ output_format = data.get('format', 'xml') try: sk, api_key = data['sk'], data['api_key'] except KeyError: raise InvalidAPIUsage( CompatError.INVALID_PARAMETERS, output_format=output_format) # Invalid parameters session = Session.load(sk) if not session: if not Token.is_valid_api_key(api_key): raise InvalidAPIUsage( CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API_KEY raise InvalidAPIUsage( CompatError.INVALID_SESSION_KEY, output_format=output_format) # Invalid Session KEY user = db_user.get(session.user_id, fetch_email=True) if mb_engine and current_app.config[ "REJECT_LISTENS_WITHOUT_USER_EMAIL"] and user["email"] is None: raise InvalidAPIUsage( CompatError.NO_EMAIL, output_format=output_format) # No email available for user in LB lookup = defaultdict(dict) for key, value in data.items(): if key in ["sk", "token", "api_key", "method", "api_sig", "format"]: continue matches = re.match('(.*)\[(\d+)\]', key) if matches: key = matches.group(1) number = matches.group(2) else: number = 0 lookup[number][key] = value if data['method'].lower() == 'track.updatenowplaying': for i, listen in lookup.items(): if 'timestamp' not in listen: listen['timestamp'] = calendar.timegm( datetime.now().utctimetuple()) # Convert to native payload then submit 'em after validation. listen_type, native_payload = _to_native_api(lookup, data['method'], output_format) try: validated_payload = [ validate_listen(listen, listen_type) for listen in native_payload ] except ListenValidationError as err: # Unsure about which LastFMError code to use but 5 or 6 probably make the most sense. # see listenbrainz.webserver.errors.py for a detailed list of all available codes raise InvalidAPIUsage(LastFMError(code=6, message=err.message), 400, output_format) user_metadata = SubmitListenUserMetadata( user_id=user['id'], musicbrainz_id=user['musicbrainz_id']) augmented_listens = insert_payload(validated_payload, user_metadata, listen_type=listen_type) # With corrections than the original submitted listen. doc, tag, text = Doc().tagtext() with tag('lfm', status='ok'): if listen_type == 'playing_now': doc.asis( create_response_for_single_listen( list(lookup.values())[0], augmented_listens[0], listen_type)) else: accepted_listens = len(lookup.values()) # Currently LB accepts all the listens and ignores none with tag('scrobbles', accepted=accepted_listens, ignored='0'): for original_listen, augmented_listen in zip( list(lookup.values()), augmented_listens): doc.asis( create_response_for_single_listen( original_listen, augmented_listen, listen_type)) return format_response( '<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()), output_format)
def test_generate(self): token = Token.generate(str(uuid.uuid4())) self.assertIsInstance(token, Token)
def test_is_valid_api_key(self): self.assertTrue(Token.is_valid_api_key(self.user.api_key)) self.assertTrue(Token.is_valid_api_key(str(uuid.uuid4())))
def record_listens(request, data): """ Submit the listen in the lastfm format to be inserted in db. Accepts listens for both track.updateNowPlaying and track.scrobble methods. """ output_format = data.get('format', 'xml') try: sk, api_key = data['sk'], data['api_key'] except KeyError: raise InvalidAPIUsage( CompatError.INVALID_PARAMETERS, output_format=output_format) # Invalid parameters session = Session.load(sk, api_key) if not session: if not Token.is_valid_api_key(api_key): raise InvalidAPIUsage( CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API_KEY raise InvalidAPIUsage( CompatError.INVALID_SESSION_KEY, output_format=output_format) # Invalid Session KEY lookup = defaultdict(dict) for key, value in data.items(): if key in ["sk", "token", "api_key", "method", "api_sig"]: continue matches = re.match('(.*)\[(\d+)\]', key) if matches: key = matches.group(1) number = matches.group(2) else: number = 0 lookup[number][key] = value if request.form['method'].lower() == 'track.updatenowplaying': for i, listen in lookup.items(): if 'timestamp' not in listen: listen['timestamp'] = calendar.timegm( datetime.now().utctimetuple()) # Convert to native payload then submit 'em after validation. listen_type, native_payload = _to_native_api(lookup, data['method'], output_format) for listen in native_payload: validate_listen(listen, listen_type) augmented_listens = insert_payload(native_payload, session.user, listen_type=listen_type) # With corrections than the original submitted listen. doc, tag, text = Doc().tagtext() with tag('lfm', status='ok'): with tag('nowplaying' if listen_type == 'playing_now' else 'scrobbles'): for origL, augL in zip(list(lookup.values()), augmented_listens): corr = defaultdict(lambda: '0') track = augL['track_metadata']['track_name'] if origL['track'] != augL['track_metadata']['track_name']: corr['track'] = '1' artist = augL['track_metadata']['artist_name'] if origL['artist'] != augL['track_metadata']['artist_name']: corr['artist'] = '1' ts = augL['listened_at'] albumArtist = artist if origL.get('albumArtist', origL['artist']) != artist: corr['albumArtist'] = '1' album = augL['track_metadata'].get('release_name', '') if origL.get('album', '') != album: corr['album'] = '1' with tag('scrobble'): with tag('track', corrected=corr['track']): text(track) with tag('artist', corrected=corr['artist']): text(artist) with tag('album', corrected=corr['album']): text(album) with tag('albumArtist', corrected=corr['albumArtist']): text(albumArtist) with tag('timestamp'): text(ts) with tag('ignoredMessage', code="0"): text('') return format_response( '<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()), output_format)
def test_generate(self): token = Token.generate(str(uuid.uuid4())) self.assertIsInstance(token, Token)
def record_listens(request, data): """ Submit the listen in the lastfm format to be inserted in db. Accepts listens for both track.updateNowPlaying and track.scrobble methods. """ output_format = data.get('format', 'xml') try: sk, api_key = data['sk'], data['api_key'] except KeyError: raise InvalidAPIUsage( CompatError.INVALID_PARAMETERS, output_format=output_format) # Invalid parameters session = Session.load(sk) if not session: if not Token.is_valid_api_key(api_key): raise InvalidAPIUsage( CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API_KEY raise InvalidAPIUsage( CompatError.INVALID_SESSION_KEY, output_format=output_format) # Invalid Session KEY lookup = defaultdict(dict) for key, value in data.items(): if key in ["sk", "token", "api_key", "method", "api_sig"]: continue matches = re.match('(.*)\[(\d+)\]', key) if matches: key = matches.group(1) number = matches.group(2) else: number = 0 lookup[number][key] = value if request.form['method'].lower() == 'track.updatenowplaying': for i, listen in lookup.items(): if 'timestamp' not in listen: listen['timestamp'] = calendar.timegm( datetime.now().utctimetuple()) # Convert to native payload then submit 'em after validation. listen_type, native_payload = _to_native_api(lookup, data['method'], output_format) for listen in native_payload: validate_listen(listen, listen_type) user = db_user.get(session.user_id) augmented_listens = insert_payload(native_payload, user, listen_type=listen_type) # With corrections than the original submitted listen. doc, tag, text = Doc().tagtext() with tag('lfm', status='ok'): if listen_type == 'playing_now': doc.asis( create_response_for_single_listen( list(lookup.values())[0], augmented_listens[0], listen_type)) else: accepted_listens = len(lookup.values()) # Currently LB accepts all the listens and ignores none with tag('scrobbles', accepted=accepted_listens, ignored='0'): for original_listen, augmented_listen in zip( list(lookup.values()), augmented_listens): doc.asis( create_response_for_single_listen( original_listen, augmented_listen, listen_type)) return format_response( '<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()), output_format)
def test_is_valid_api_key(self): self.assertTrue(Token.is_valid_api_key(self.user.api_key)) self.assertTrue(Token.is_valid_api_key(str(uuid.uuid4())))