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))