450 lines
17 KiB
Python
450 lines
17 KiB
Python
from flask import Blueprint, request, jsonify
|
|
from google.cloud import firestore
|
|
from werkzeug.security import generate_password_hash
|
|
|
|
import os
|
|
import json
|
|
import logging
|
|
from datetime import datetime
|
|
|
|
from music.api.decorators import login_required, login_or_basic_auth, admin_required, gae_cron, cloud_task
|
|
from music.cloud.tasks import execute_all_user_playlists, execute_user_playlists, create_run_user_playlist_task, \
|
|
create_play_user_playlist_task
|
|
from music.tasks.run_user_playlist import run_user_playlist as run_user_playlist
|
|
from music.tasks.play_user_playlist import play_user_playlist as play_user_playlist
|
|
|
|
from music.model.user import User
|
|
from music.model.playlist import Playlist
|
|
|
|
import music.db.database as database
|
|
|
|
blueprint = Blueprint('api', __name__)
|
|
db = firestore.Client()
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
@blueprint.route('/playlists', methods=['GET'])
|
|
@login_or_basic_auth
|
|
def get_playlists(user=None):
|
|
assert user is not None
|
|
return jsonify({
|
|
'playlists': [i.to_dict() for i in Playlist.collection.parent(user.key).fetch()]
|
|
}), 200
|
|
|
|
|
|
@blueprint.route('/playlist', methods=['GET', 'POST', 'PUT', 'DELETE'])
|
|
@login_or_basic_auth
|
|
def playlist_route(user=None):
|
|
|
|
if request.method == 'GET' or request.method == 'DELETE':
|
|
playlist_name = request.args.get('name', None)
|
|
|
|
if playlist_name:
|
|
playlist = Playlist.collection.parent(user.key).filter('name', '==', playlist_name).get()
|
|
|
|
if playlist is None:
|
|
return jsonify({'error': f'playlist {playlist_name} not found'}), 404
|
|
|
|
if request.method == "GET":
|
|
return jsonify(playlist.to_dict()), 200
|
|
|
|
elif request.method == 'DELETE':
|
|
Playlist.collection.parent(user.key).delete(key=playlist.key)
|
|
return jsonify({"message": 'playlist deleted', "status": "success"}), 200
|
|
|
|
else:
|
|
return jsonify({"error": 'no name requested'}), 400
|
|
|
|
elif request.method == 'POST' or request.method == 'PUT':
|
|
|
|
request_json = request.get_json()
|
|
|
|
if 'name' not in request_json:
|
|
return jsonify({'error': "no name provided"}), 400
|
|
|
|
playlist_name = request_json['name']
|
|
|
|
playlist_parts = request_json.get('parts', None)
|
|
|
|
playlist_references = []
|
|
|
|
if request_json.get('playlist_references', None):
|
|
if request_json['playlist_references'] != -1:
|
|
for i in request_json['playlist_references']:
|
|
|
|
updating_playlist = Playlist.collection.parent(user.key).filter('name', '==', i).get()
|
|
if updating_playlist is not None:
|
|
playlist_references.append(db.document(updating_playlist.key))
|
|
else:
|
|
return jsonify({"message": f'managed playlist {i} not found', "status": "error"}), 400
|
|
|
|
if len(playlist_references) == 0 and request_json.get('playlist_references', None) != -1:
|
|
playlist_references = None
|
|
|
|
playlist_uri = request_json.get('uri', None)
|
|
playlist_shuffle = request_json.get('shuffle', None)
|
|
playlist_type = request_json.get('type', None)
|
|
|
|
playlist_day_boundary = request_json.get('day_boundary', None)
|
|
playlist_add_this_month = request_json.get('add_this_month', None)
|
|
playlist_add_last_month = request_json.get('add_last_month', None)
|
|
|
|
playlist_library_tracks = request_json.get('include_library_tracks', None)
|
|
|
|
playlist_recommendation = request_json.get('include_recommendations', None)
|
|
playlist_recommendation_sample = request_json.get('recommendation_sample', None)
|
|
|
|
playlist_chart_range = request_json.get('chart_range', None)
|
|
playlist_chart_limit = request_json.get('chart_limit', None)
|
|
|
|
playlist = Playlist.collection.parent(user.key).filter('name', '==', playlist_name).get()
|
|
|
|
if request.method == 'PUT':
|
|
|
|
if playlist is not None:
|
|
return jsonify({'error': 'playlist already exists'}), 400
|
|
|
|
from music.tasks.create_playlist import create_playlist as create_playlist
|
|
|
|
new_db_playlist = Playlist(parent=user.key)
|
|
|
|
new_db_playlist.name = playlist_name
|
|
new_db_playlist.parts = playlist_parts
|
|
new_db_playlist.playlist_references = playlist_references
|
|
|
|
new_db_playlist.include_library_tracks = playlist_library_tracks
|
|
new_db_playlist.include_recommendations = playlist_recommendation
|
|
new_db_playlist.recommendation_sample = playlist_recommendation_sample
|
|
|
|
new_db_playlist.shuffle = playlist_shuffle
|
|
|
|
new_db_playlist.type = playlist_type
|
|
new_db_playlist.last_updated = datetime.utcnow()
|
|
new_db_playlist.lastfm_stat_last_refresh = datetime.utcnow()
|
|
|
|
new_db_playlist.day_boundary = playlist_day_boundary
|
|
new_db_playlist.add_this_month = playlist_add_this_month
|
|
new_db_playlist.add_last_month = playlist_add_last_month
|
|
|
|
new_db_playlist.chart_range = playlist_chart_range
|
|
new_db_playlist.chart_limit = playlist_chart_limit
|
|
|
|
if user.spotify_linked:
|
|
new_playlist = create_playlist(user, playlist_name)
|
|
new_db_playlist.uri = str(new_playlist.uri)
|
|
|
|
new_db_playlist.save()
|
|
logger.info(f'added {user.username} / {playlist_name}')
|
|
|
|
return jsonify({"message": 'playlist added', "status": "success"}), 201
|
|
|
|
elif request.method == 'POST':
|
|
|
|
if playlist is None:
|
|
return jsonify({'error': "playlist doesn't exist"}), 400
|
|
|
|
updating_playlist = Playlist.collection.parent(user.key).filter('name', '==', playlist_name).get()
|
|
|
|
if playlist_parts is not None:
|
|
if playlist_parts == -1:
|
|
updating_playlist.parts = []
|
|
else:
|
|
updating_playlist.parts = playlist_parts
|
|
|
|
if playlist_references is not None:
|
|
if playlist_references == -1:
|
|
updating_playlist.playlist_references = []
|
|
else:
|
|
updating_playlist.playlist_references = playlist_references
|
|
|
|
if playlist_uri is not None:
|
|
updating_playlist.uri = playlist_uri
|
|
|
|
if playlist_shuffle is not None:
|
|
updating_playlist.shuffle = playlist_shuffle
|
|
|
|
if playlist_day_boundary is not None:
|
|
updating_playlist.day_boundary = playlist_day_boundary
|
|
|
|
if playlist_add_this_month is not None:
|
|
updating_playlist.add_this_month = playlist_add_this_month
|
|
|
|
if playlist_add_last_month is not None:
|
|
updating_playlist.add_last_month = playlist_add_last_month
|
|
|
|
if playlist_library_tracks is not None:
|
|
updating_playlist.include_library_tracks = playlist_library_tracks
|
|
|
|
if playlist_recommendation is not None:
|
|
updating_playlist.include_recommendations = playlist_recommendation
|
|
|
|
if playlist_recommendation_sample is not None:
|
|
updating_playlist.recommendation_sample = playlist_recommendation_sample
|
|
|
|
if playlist_chart_range is not None:
|
|
updating_playlist.chart_range = playlist_chart_range
|
|
|
|
if playlist_chart_limit is not None:
|
|
updating_playlist.chart_limit = playlist_chart_limit
|
|
|
|
if playlist_type is not None:
|
|
# TODO check acceptable value
|
|
updating_playlist.type = playlist_type
|
|
|
|
updating_playlist.update()
|
|
logger.info(f'updated {user.username} / {playlist_name}')
|
|
|
|
return jsonify({"message": 'playlist updated', "status": "success"}), 200
|
|
|
|
|
|
@blueprint.route('/user', methods=['GET', 'POST'])
|
|
@login_or_basic_auth
|
|
def user_route(user=None):
|
|
assert user is not None
|
|
|
|
if request.method == 'GET':
|
|
return jsonify(user.to_dict()), 200
|
|
|
|
else: # POST
|
|
request_json = request.get_json()
|
|
|
|
if 'username' in request_json:
|
|
if request_json['username'].strip().lower() != user.username:
|
|
if user.type != "admin":
|
|
return jsonify({'status': 'error', 'message': 'unauthorized'}), 401
|
|
|
|
user = User.collection.filter('username', '==', request_json['username'].strip().lower()).get()
|
|
|
|
if 'locked' in request_json:
|
|
if user.type == "admin":
|
|
logger.info(f'updating lock {user.username} / {request_json["locked"]}')
|
|
user.locked = request_json['locked']
|
|
|
|
if 'spotify_linked' in request_json:
|
|
logger.info(f'deauthing {user.username}')
|
|
if request_json['spotify_linked'] is False:
|
|
user.access_token = None
|
|
user.refresh_token = None
|
|
user.spotify_linked = False
|
|
|
|
if 'lastfm_username' in request_json:
|
|
logger.info(f'updating lastfm username {user.username} -> {request_json["lastfm_username"]}')
|
|
user.lastfm_username = request_json['lastfm_username']
|
|
|
|
user.update()
|
|
|
|
logger.info(f'updated {user.username}')
|
|
|
|
return jsonify({'message': 'account updated', 'status': 'succeeded'}), 200
|
|
|
|
|
|
@blueprint.route('/users', methods=['GET'])
|
|
@login_or_basic_auth
|
|
@admin_required
|
|
def users(user=None):
|
|
return jsonify({
|
|
'accounts': [i.to_dict() for i in User.collection.fetch()]
|
|
}), 200
|
|
|
|
|
|
@blueprint.route('/user/password', methods=['POST'])
|
|
@login_required
|
|
def change_password(user=None):
|
|
request_json = request.get_json()
|
|
|
|
if 'new_password' in request_json and 'current_password' in request_json:
|
|
|
|
if len(request_json['new_password']) == 0:
|
|
return jsonify({"error": 'zero length password'}), 400
|
|
|
|
if len(request_json['new_password']) > 30:
|
|
return jsonify({"error": 'password too long'}), 400
|
|
|
|
if user.check_password(request_json['current_password']):
|
|
user.password = generate_password_hash(request_json['new_password'])
|
|
user.update()
|
|
logger.info(f'password udpated {user.username}')
|
|
|
|
return jsonify({"message": 'password changed', "status": "success"}), 200
|
|
else:
|
|
logger.warning(f"incorrect password {user.username}")
|
|
return jsonify({'error': 'wrong password provided'}), 401
|
|
|
|
else:
|
|
return jsonify({'error': 'malformed request, no old_password/new_password'}), 400
|
|
|
|
|
|
@blueprint.route('/playlist/play', methods=['POST'])
|
|
@login_or_basic_auth
|
|
def play_playlist(user=None):
|
|
|
|
request_json = request.get_json()
|
|
|
|
request_parts = request_json.get('parts', None)
|
|
request_playlist_type = request_json.get('playlist_type', 'default')
|
|
request_playlists = request_json.get('playlists', None)
|
|
request_shuffle = request_json.get('shuffle', False)
|
|
request_include_recommendations = request_json.get('include_recommendations', True)
|
|
request_recommendation_sample = request_json.get('recommendation_sample', 10)
|
|
request_day_boundary = request_json.get('day_boundary', 10)
|
|
request_add_this_month = request_json.get('add_this_month', False)
|
|
request_add_last_month = request_json.get('add_last_month', False)
|
|
|
|
request_device_name = request_json.get('device_name', None)
|
|
|
|
logger.info(f'playing {user.username}')
|
|
|
|
if (request_parts and len(request_parts) > 0) or (request_playlists and len(request_playlists) > 0):
|
|
|
|
if os.environ.get('DEPLOY_DESTINATION', None) == 'PROD':
|
|
create_play_user_playlist_task(user.username,
|
|
parts=request_parts,
|
|
playlist_type=request_playlist_type,
|
|
playlists=request_playlists,
|
|
shuffle=request_shuffle,
|
|
include_recommendations=request_include_recommendations,
|
|
recommendation_sample=request_recommendation_sample,
|
|
day_boundary=request_day_boundary,
|
|
add_this_month=request_add_this_month,
|
|
add_last_month=request_add_last_month,
|
|
device_name=request_device_name)
|
|
else:
|
|
play_user_playlist(user.username,
|
|
parts=request_parts,
|
|
playlist_type=request_playlist_type,
|
|
playlists=request_playlists,
|
|
shuffle=request_shuffle,
|
|
include_recommendations=request_include_recommendations,
|
|
recommendation_sample=request_recommendation_sample,
|
|
day_boundary=request_day_boundary,
|
|
add_this_month=request_add_this_month,
|
|
add_last_month=request_add_last_month,
|
|
device_name=request_device_name)
|
|
|
|
return jsonify({'message': 'execution requested', 'status': 'success'}), 200
|
|
else:
|
|
logger.error(f'no playlists/parts {user.username}')
|
|
return jsonify({'error': 'insufficient playlist sources'}), 400
|
|
|
|
|
|
@blueprint.route('/playlist/play/task', methods=['POST'])
|
|
@cloud_task
|
|
def play_playlist_task():
|
|
payload = request.get_data(as_text=True)
|
|
if payload:
|
|
payload = json.loads(payload)
|
|
logger.info(f'playing {payload["username"]}')
|
|
|
|
play_user_playlist(payload['username'],
|
|
parts=payload['parts'],
|
|
playlist_type=payload['playlist_type'],
|
|
playlists=payload['playlists'],
|
|
shuffle=payload['shuffle'],
|
|
include_recommendations=payload['include_recommendations'],
|
|
recommendation_sample=payload['recommendation_sample'],
|
|
day_boundary=payload['day_boundary'],
|
|
add_this_month=payload['add_this_month'],
|
|
add_last_month=payload['add_last_month'],
|
|
device_name=payload['device_name'])
|
|
|
|
return jsonify({'message': 'executed playlist', 'status': 'success'}), 200
|
|
|
|
|
|
@blueprint.route('/playlist/run', methods=['GET'])
|
|
@login_or_basic_auth
|
|
def run_playlist(user=None):
|
|
|
|
playlist_name = request.args.get('name', None)
|
|
|
|
if playlist_name:
|
|
|
|
if os.environ.get('DEPLOY_DESTINATION', None) == 'PROD':
|
|
create_run_user_playlist_task(user.username, playlist_name)
|
|
else:
|
|
run_user_playlist(user.username, playlist_name)
|
|
|
|
return jsonify({'message': 'execution requested', 'status': 'success'}), 200
|
|
|
|
else:
|
|
logger.warning('no playlist requested')
|
|
return jsonify({"error": 'no name requested'}), 400
|
|
|
|
|
|
@blueprint.route('/playlist/run/task', methods=['POST'])
|
|
@cloud_task
|
|
def run_playlist_task():
|
|
|
|
payload = request.get_data(as_text=True)
|
|
if payload:
|
|
payload = json.loads(payload)
|
|
|
|
logger.info(f'running {payload["username"]} / {payload["name"]}')
|
|
|
|
run_user_playlist(payload['username'], payload['name'])
|
|
|
|
return jsonify({'message': 'executed playlist', 'status': 'success'}), 200
|
|
|
|
|
|
@blueprint.route('/playlist/run/user', methods=['GET'])
|
|
@login_or_basic_auth
|
|
def run_user(user=None):
|
|
|
|
if user.type == 'admin':
|
|
user_name = request.args.get('username', user.username)
|
|
else:
|
|
user_name = user.username
|
|
|
|
execute_user_playlists(user_name)
|
|
|
|
return jsonify({'message': 'executed user', 'status': 'success'}), 200
|
|
|
|
|
|
@blueprint.route('/playlist/run/user/task', methods=['POST'])
|
|
@cloud_task
|
|
def run_user_task():
|
|
|
|
payload = request.get_data(as_text=True)
|
|
if payload:
|
|
execute_user_playlists(payload)
|
|
return jsonify({'message': 'executed user', 'status': 'success'}), 200
|
|
|
|
|
|
@blueprint.route('/playlist/run/users', methods=['GET'])
|
|
@login_or_basic_auth
|
|
@admin_required
|
|
def run_users(user=None):
|
|
|
|
execute_all_user_playlists()
|
|
return jsonify({'message': 'executed all users', 'status': 'success'}), 200
|
|
|
|
|
|
@blueprint.route('/playlist/run/users/cron', methods=['GET'])
|
|
@gae_cron
|
|
def run_users_cron():
|
|
|
|
execute_all_user_playlists()
|
|
return jsonify({'status': 'success'}), 200
|
|
|
|
|
|
@blueprint.route('/playlist/image', methods=['GET'])
|
|
@login_or_basic_auth
|
|
def image(user=None):
|
|
|
|
name = request.args.get('name', None)
|
|
|
|
if name is None:
|
|
return jsonify({'error': "no name provided"}), 400
|
|
|
|
_playlist = Playlist.collection.parent(user.key).filter('name', '==', name).get()
|
|
if _playlist is None:
|
|
return jsonify({'error': "playlist not found"}), 404
|
|
|
|
net = database.get_authed_spotify_network(user)
|
|
|
|
spotify_playlist = net.get_playlist(uri_string=_playlist.uri)
|
|
|
|
if spotify_playlist is None:
|
|
return jsonify({'error': "no spotify playlist returned"}), 404
|
|
|
|
return jsonify({'images': spotify_playlist.images, 'status': 'success'}), 200
|