def addSong():
try:
if 'song_id' not in request.args:
create_error_response("Missing song_id")
song = Song.query.get(request.args['song_id'])
if song is None:
return create_error_response("No such song exists")
entry = User_Song()
data = {}
data['user_id'] = g.user_id
data['song_id'] = request.args['song_id']
entry.import_data(data)
db.session.add(entry)
db.session.commit()
return create_success_response()
except Exception as e:
db.session.rollback()
return create_error_response(str(e))
def getArtist():
try:
response = {}
if 'id' in request.args:
artist = Artist.query.get(int(request.args['id']))
if artist is not None:
album_list = []
albums = Album.query.filter_by(artist_id=artist.id)
for album in albums:
album_list.append(album.export_data())
response['artist'] = artist.export_data()
response['album_list'] = album_list
return create_success_response(response)
return create_error_response("No data found")
except Exception as e:
return create_error_response(str(e))
def getAlbum():
try:
response = {}
if 'id' in request.args:
album = Album.query.get(int(request.args['id']))
if album is not None:
song_list = []
songs = Song.query.filter_by(album_id=album.id)
for song in songs:
userSong = User_Song.query.filter_by(
User_Song.song_id == song.id).first()
song_list.append(
song.export_data(userSong.user_id == g.user_id))
response['album'] = album.export_data()
response['song_list'] = song_list
return create_success_response(response)
return create_error_response("No data found")
except Exception as e:
return create_error_response(str(e))
def process() -> Response:
"""
Takes file with multipart/form-data format and creates async task to
resize it
:return: Sends response to client
"""
current_app.logger.info('Attempt to create resizing task')
if 'file' not in request.files:
current_app.logger.warning(
"No file given: 'file' not in request.files")
return create_error_response(422, 'No file given')
current_app.logger.info('Reading file')
file: FileStorage = request.files['file']
current_app.logger.info(f'File name: {file.filename}')
if file.filename == '':
current_app.logger.warning("No file given: file.filename is ''")
return create_error_response(422, 'No file given')
current_app.logger.info('Reading resize parameters')
data = request.values
if not size_valid(data):
current_app.logger.warning("File size parameters are invalid")
return create_error_response(422, 'Invalid size')
h = int(data['height'])
w = int(data['width'])
if file and allowed_extension(file.filename):
current_app.logger.info('Saving file')
task_id = celery.uuid()
extension = file.filename.rsplit('.', 1)[1]
filename = secure_filename(f'{task_id}.{extension}')
file.save(os.path.join(config.upload_dir, filename))
current_app.logger.info(f"File saved under name '{filename}'")
current_app.logger.info('Creating celery task')
try:
task: tasks.celery.Task = tasks.resize_image.apply_async(
args=[filename, w, h], task_id=task_id)
# Hack to be able to check the existence of the task:
# PENDING task state is equal not existing task
task.backend.store_result(task.id, None, 'SENT')
except kombu.exceptions.OperationalError as e:
current_app.logger.critical(f'Cannot connect to redis: {e}')
return create_error_response(500, 'Server error')
current_app.logger.info('Request accepted, task was sent into queue')
return create_response(202,
status='accepted',
message='Upload complete',
task_id=task.id)
else:
current_app.logger.warning(f'Wrong file extension: {file.filename}')
return create_error_response(422, 'Invalid extension')
def getSongList():
try:
page_number = 0
if 'page' in request.args:
page_number = request.args['page']
condition = None
if 'album_id' in request.args:
songs = paginatedQuery(Song, page_number,
Song.album_id == request.args['album_id'])
condition = Song.album_id == request.args['album_id']
else:
songs = paginatedQuery(Song, page_number)
song_list = []
for song in songs:
userSong = User_Song.query.filter_by(
User_Song.song_id == song.id).first()
song_list.append(song.export_data(userSong.user_id == g.user_id))
return create_success_list_response(song_list,
getPageCount(Song, condition))
except Exception as e:
return create_error_response(str(e))
def getAlbumList():
try:
page_number = 0
if 'page' in request.args:
page_number = request.args['page']
condition = None
if 'artist_id' in request.args:
albums = paginatedQuery(
Album, page_number,
Album.artist_id == request.args['artist_id'])
condition = Album.artist_id == request.args['artist_id']
else:
albums = paginatedQuery(Album, page_number)
album_list = []
for album in albums:
album_list.append(album.export_data())
return create_success_list_response(album_list,
getPageCount(Album, condition))
except Exception as e:
return create_error_response(str(e))
def getHome():
try:
songs = Song.query.order_by(Song.id.desc()).limit(5)
artists = Artist.query.order_by(Artist.id.desc()).limit(5)
albums = Album.query.order_by(Album.id.desc()).limit(5)
sl = []
arl = []
all = []
for song in songs:
sl.append(song.export_data())
for artist in artists:
arl.append(artist.export_data())
for album in albums:
all.append(album.export_data())
return jsonify({
"response": "success",
"artists": arl,
"albums": all,
"songs": sl
})
except Exception as e:
return create_error_response(str(e))
def task_status(task_id: UUID) -> Response:
"""
Returns task state or 404 if task does not exist
:param task_id: UUID of the task
:return: Response with task state or 404 error
"""
current_app.logger.info(f'Attempt to get task status with id: {task_id}')
task_result = tasks.celery.AsyncResult(str(task_id))
state = 'PENDING'
try:
state = task_result.state
except AttributeError as e:
current_app.logger.critical(f'Celery backend disabled: '
f'{e}')
if state == 'PENDING':
current_app.logger.info(f'Attempt rejected: the task does not exist')
return create_error_response(404, message='Task not found')
current_app.logger.info(f'Returned state ({state}) '
f'of task with id {task_id}')
return create_response(200, status=state)
def test_create_error_response(self):
response = utils.create_error_response(404, 'Test error')
self.assertEqual(404, response.status_code)
self.assertEqual('application/json', response.content_type)
self.assertIn('result', response.get_json())
self.assertIn('message', response.get_json())
self.assertEqual(response.get_json()['result'], 'error')
self.assertEqual(response.get_json()['message'], 'Test error')
def get_client_detail( client_id ):
client = Client.query.get( client_id )
if client is None:
return create_error_response( 404, 'Client does not exist' )
response = {
'client' : client.serialize()
}
return jsonify( response )
def delete_client( client_id ):
client = Client.query.get( client_id )
if client is None:
return create_error_response( 404, 'Client does not exist' )
client.delete()
response = {
'msg' : 'Client %r successfully deleted' % client.id
}
return jsonify( response )
def getSong():
try:
response = {}
if 'id' in request.args:
song = Song.query.get(int(request.args['id']))
if song is not None:
response['song'] = song.export_data()
return create_success_response(response)
return create_error_response("No data found")
except Exception as e:
return create_error_response(str(e))
def me():
try:
user = User.query.filter_by(id=g.user_id).first()
ret = user.export_data()
ret['response'] = 'success'
return create_success_response(ret)
except Exception as e:
return create_error_response(str(e))
def getArtistList():
try:
page_number = 0
if 'page' in request.args:
page_number = request.args['page']
artists = paginatedQuery(Artist, page_number)
artist_list = []
for artist in artists:
artist_list.append(artist.export_data())
return create_success_list_response(artist_list, getPageCount(Artist))
except Exception as e:
return create_error_response(str(e))
def addArtist():
try:
data = request.json
artist = Artist()
artist.import_data(data)
db.session.add(artist)
db.session.commit()
return create_success_response(artist.export_data())
except Exception as e:
db.session.rollback()
return create_error_response(str(e))
def addSong():
try:
data = request.json
song = Song()
song.import_data(data)
db.session.add(song)
db.session.commit()
return create_success_response(song.export_data())
except Exception as e:
db.session.rollback()
return create_error_response(str(e))
def addAlbum():
try:
data = request.json
album = Album()
album.import_data(data)
db.session.add(album)
db.session.commit()
return create_success_response(album.export_data())
except Exception as e:
db.session.rollback()
return create_error_response(str(e))
def getUserSongList():
try:
song_list = []
songs = User_Song.query.join(Song).add_columns(
Song.name, Song.stream_url, Song.album_id,
Song.id).filter(User_Song.user_id == g.user_id)
for song in songs:
album = Album.query.get(song.album_id)
song_list.append({
"id": song.id,
"name": song.name,
"stream_url": song.stream_url,
"image_url": album.image_url
})
return create_success_list_response(song_list, 0)
except Exception as e:
return create_error_response(str(e))
def result(task_id: UUID) -> Response:
"""
Accepts the task ID and returns the result. The result does not exist if
the task identifier is invalid, or if the task has not been completed
:param task_id: UUID of the task
:return: Response with task result or 404 error
"""
current_app.logger.info(f'Attempt to get task result with id: {task_id}')
task_result = tasks.celery.AsyncResult(str(task_id))
state = 'PENDING'
try:
state = task_result.state
except AttributeError as e:
current_app.logger.critical(f'Celery backend disabled: {e}')
if state != 'SUCCESS':
current_app.logger.info(f'Attempt rejected: the task does not exist or'
f' is not completed yet')
return create_error_response(404, message='Result not found')
else:
path = task_result.get()
current_app.logger.debug(path)
@after_this_request
def remove_file(response):
current_app.logger.info(f'Removing file {path}')
os.remove(path)
return response
directory = os.path.dirname(path)
file = os.path.basename(path)
current_app.logger.info(f'Sending file to client {directory}/{file}')
return send_from_directory(directory, file)
def android_google():
try:
if 'google_token' not in request.args:
return create_error_response("Missing google_token")
url = "https://www.googleapis.com/oauth2/v3/tokeninfo?id_token=" + str(
request.args['google_token'])
response = requests.get(url)
data = json.loads(response.text)
if response.status_code == 200:
email = data.get('email', None)
name = data.get('name', None)
image_url = data.get('picture', None)
profile_sub = data.get('sub', 0)
user = User.query.filter_by(email=email).first()
# if user has registered with same email before, update
if user is not None:
user.name = name
user.image_url = image_url
db.session.add(user)
# if user does not exist, create
else:
user = User()
data = {"name": name, "image_url": image_url, "email": email}
user.import_data(data)
db.session.add(user)
db.session.flush()
token = create_token(user)
db.session.commit()
response = {"token": token, "user_detail": user.export_data()}
return create_success_response(response)
else:
return create_error_response(
data.get('error_description',
'Failed to login. Please try again.'))
except Exception as e:
db.session.rollback()
return create_error_response(str(e))
