def update_user_group(user, uid):
"""Join or leave a group."""
helpers.ensure_users_match(user, uid)
if request.method == 'DELETE':
if user.group is not None:
if user.group.master == user:
user.group.master = None
event = GroupEvent(user.group, user, events.LEAVE, None)
g.store.add(event)
user.group = None
return helpers.success()
try:
gid = int(request.form['gid'])
except:
raise helpers.BadRequest(errors.MISSING_FIELD,
"cannot to parse group ID")
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP,
"group does not exist")
if user.group != group:
if user.group is not None:
if user.group.master == user:
# The user was his old group's master.
user.group.master == None
event = GroupEvent(user.group, user, events.LEAVE, None)
g.store.add(event)
user.group = group
event = GroupEvent(group, user, events.JOIN, None)
g.store.add(event)
return helpers.success()
def update_user_group(user, uid):
"""Join or leave a group."""
helpers.ensure_users_match(user, uid)
if request.method == 'DELETE':
if user.group is not None:
if user.group.master == user:
user.group.master = None
event = GroupEvent(user.group, user, events.LEAVE, None)
g.store.add(event)
user.group = None
return helpers.success()
try:
gid = int(request.form['gid'])
except:
raise helpers.BadRequest(errors.MISSING_FIELD,
"cannot to parse group ID")
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP, "group does not exist")
if user.group != group:
if user.group is not None:
if user.group.master == user:
# The user was his old group's master.
user.group.master == None
event = GroupEvent(user.group, user, events.LEAVE, None)
g.store.add(event)
user.group = group
event = GroupEvent(group, user, events.JOIN, None)
g.store.add(event)
return helpers.success()
def do_GET(self):
self.path = str(self.path)
"""
"Hook" events and processing commands
"""
if self.path == '/':
self._sendHeaders(200)
self.wfile.write(
'<meta http-equiv="refresh" content="0; url=/HTML/index.html" />'
)
return
elif self.path.startswith('/play'):
MP3 = urllib.unquote(self.path.split('?')[1])
_player.play('./MP3/{}'.format(MP3))
self._sendHeaders(200)
self.wfile.write(helpers.success("Now Playing: {}".format(MP3)))
return
elif self.path == '/stop':
_player.stop()
self._sendHeaders(200)
self.wfile.write(helpers.success("stopped"))
return
elif self.path.startswith('/pause'):
_player.pause()
self._sendHeaders(200)
self.wfile.write(helpers.success("paused"))
return
if self.path.startswith('/list'):
self._sendHeaders(200)
self.wfile.write(helpers.playlist(MP3_PATH))
return
else:
try:
self.page = open(os.path.abspath(self.path[1:]), 'r').read()
if self.path.endswith('.css'):
self._sendHeaders(200, 'text/css')
elif self.path.endswith(".js"):
self._sendHeaders(200, 'application/javascript')
else:
self._sendHeaders(200)
self.wfile.write(self.page)
except IOError:
self.send_error(404, 'Not Found')
def add_rating(user, gid):
"""Take the DJ spot (if it is available)."""
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP,
"group does not exist")
try:
artist = request.form['artist']
title = request.form['title']
rating = max(1, min(5, int(request.form['rating'])))
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing artist, title or rating")
except ValueError:
raise helpers.BadRequest(errors.INVALID_RATING,
"rating is invalid")
if user.group != group:
raise helpers.Unauthorized("you are not in this group")
track = g.store.find(Track,
(Track.artist == artist) & (Track.title == title)).one()
if track is None:
raise helpers.BadRequest(errors.INVALID_TRACK,
"track not found")
# Add a group event.
event = GroupEvent(group, user, events.RATING)
event.payload = {
'artist': track.artist,
'title': track.title,
'rating': rating,
}
g.store.add(event)
# Add a library entry.
set_rating(user, track.artist, track.title, rating)
return helpers.success()
def dump_library(user, uid):
"""Dump (create or replace) a user's library."""
helpers.ensure_users_match(user, uid)
current_entries = local_valid_entries(user)
next_entries = set()
for json_entry in request.form.getlist('entry'):
try:
entry = json.loads(json_entry)
artist = entry['artist']
title = entry['title']
local_id = int(entry['local_id'])
except:
raise helpers.BadRequest(errors.INVALID_LIBENTRY,
"not a valid library entry")
key = hashlib.sha1(
artist.encode('utf-8') + title.encode('utf-8') +
str(local_id)).digest()
next_entries.add(key)
if key not in current_entries:
set_lib_entry(user, artist, title, local_id=local_id)
# Invalidate entries that are not in the request.
for key, entry in current_entries.iteritems():
if key not in next_entries:
entry.is_valid = False
# Update the user's model.
g.store.flush()
predict.Model(user).generate(g.store)
return helpers.success()
def add_rating(user, gid):
"""Take the DJ spot (if it is available)."""
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP, "group does not exist")
try:
artist = request.form['artist']
title = request.form['title']
rating = max(1, min(5, int(request.form['rating'])))
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing artist, title or rating")
except ValueError:
raise helpers.BadRequest(errors.INVALID_RATING, "rating is invalid")
if user.group != group:
raise helpers.Unauthorized("you are not in this group")
track = g.store.find(Track, (Track.artist == artist) &
(Track.title == title)).one()
if track is None:
raise helpers.BadRequest(errors.INVALID_TRACK, "track not found")
# Add a group event.
event = GroupEvent(group, user, events.RATING)
event.payload = {
'artist': track.artist,
'title': track.title,
'rating': rating,
}
g.store.add(event)
# Add a library entry.
set_rating(user, track.artist, track.title, rating)
return helpers.success()
def update_library(user, uid):
"""Update (add or delete) a user's library."""
helpers.ensure_users_match(user, uid)
current_entries = local_valid_entries(user)
for json_delta in request.form.getlist('delta'):
try:
delta = json.loads(json_delta)
delta_type = delta['type']
artist = delta['entry']['artist']
title = delta['entry']['title']
local_id = int(delta['entry']['local_id'])
except:
raise helpers.BadRequest(errors.INVALID_DELTA,
"not a valid library delta")
key = hashlib.sha1(
artist.encode('utf-8') + title.encode('utf-8') +
str(local_id)).digest()
if delta_type == 'PUT':
if key not in current_entries:
set_lib_entry(user, artist, title, local_id=local_id)
elif delta_type == 'DELETE':
if key in current_entries:
current_entries[key].is_valid = False
else:
# Unknown delta type.
raise helpers.BadRequest(errors.INVALID_DELTA,
"not a valid library delta")
# Update the user's model.
g.store.flush()
predict.Model(user).generate(g.store)
return helpers.success()
def changepassword():
if request.method == "POST":
# Check all fields are filled
if not request.form.get("currentpassword"):
return error("Please introduce your current password.")
elif not request.form.get("newpassword"):
return error("Please introduce your new password.")
elif not request.form.get("confirmation"):
return error(
"Please introduce the confirmation of your new password.")
elif request.form.get("newpassword") != request.form.get(
"confirmation"):
return error("New passwords don't match. Try again.")
# Check old password is correct
rows = db.execute("SELECT * FROM users WHERE user_id = :user_id",
user_id=session["user_id"])
if check_password_hash(rows[0]["hash"],
request.form.get("currentpassword")):
hash = generate_password_hash(request.form.get("newpassword"))
db.execute(
"UPDATE users SET hash = :hash WHERE user_id = :user_id",
hash=hash,
user_id=session["user_id"])
else:
return error("Current password is not correct.")
# Redirect to homepage after changing password
return success("Password changed successfully.")
else:
return render_template("editaccount.html")
def changeusername():
if request.method == "POST":
# Check all fields are filled
if not request.form.get("newusername"):
return error("Please introduce your new username.")
elif not request.form.get("currentpassword"):
return error("Please introduce your password.")
# Check old password is correct
rows = db.execute("SELECT * FROM users WHERE user_id = :user_id",
user_id=session["user_id"])
if check_password_hash(rows[0]["hash"],
request.form.get("currentpassword")):
username = request.form.get("newusername")
db.execute(
"UPDATE users SET username = :username WHERE user_id = :user_id",
username=username,
user_id=session["user_id"])
else:
return error("Password is not correct.")
# Redirect to homepage after changing password
success_msg = "Username changed. You shall be " + username + " from now on."
return success(success_msg)
else:
return render_template("editaccount.html")
def add():
if request.method == "POST":
# Check all fields are filled
if not request.form.get("placename"):
return error("Please add name of the place.")
elif not request.form.get("latitude"):
return error("Please add latitude of the place.")
elif not request.form.get("longitude"):
return error("Please add longitude of the place.")
elif not request.form.get("country"):
return error("Please add country of the place.")
# Store new place into users database
placeKeyId = db.execute(
"INSERT INTO places (placename, latitude, longitude, register_user_id, country, ratings_avg, ratings_num) VALUES (:placename, :latitude, :longitude, :user_id, :country, :ratings_avg, :ratings_num)",
placename=request.form.get("placename"),
latitude=request.form.get("latitude"),
longitude=request.form.get("longitude"),
user_id=session["user_id"],
country=request.form.get("country"),
ratings_avg=0,
ratings_num=0)
if request.form.get("description"):
db.execute(
"UPDATE places SET description = :description WHERE placename = :placename",
description=request.form.get("description"),
placename=request.form.get("placename"))
return success("Place added successfully.")
else:
return render_template("add.html")
def update_library(user, uid):
"""Update (add or delete) a user's library."""
helpers.ensure_users_match(user, uid)
current_entries = local_valid_entries(user)
for json_delta in request.form.getlist('delta'):
try:
delta = json.loads(json_delta)
delta_type = delta['type']
artist = delta['entry']['artist']
title = delta['entry']['title']
local_id = int(delta['entry']['local_id'])
except:
raise helpers.BadRequest(errors.INVALID_DELTA,
"not a valid library delta")
key = hashlib.sha1(artist.encode('utf-8')
+ title.encode('utf-8') + str(local_id)).digest()
if delta_type == 'PUT':
if key not in current_entries:
set_lib_entry(user, artist, title, local_id=local_id)
elif delta_type == 'DELETE':
if key in current_entries:
current_entries[key].is_valid = False
else:
# Unknown delta type.
raise helpers.BadRequest(errors.INVALID_DELTA,
"not a valid library delta")
# Update the user's model.
g.store.flush()
predict.Model(user).generate(g.store)
return helpers.success()
def dump_library(user, uid):
"""Dump (create or replace) a user's library."""
helpers.ensure_users_match(user, uid)
current_entries = local_valid_entries(user)
next_entries = set()
for json_entry in request.form.getlist('entry'):
try:
entry = json.loads(json_entry)
artist = entry['artist']
title = entry['title']
local_id = int(entry['local_id'])
except:
raise helpers.BadRequest(errors.INVALID_LIBENTRY,
"not a valid library entry")
key = hashlib.sha1(artist.encode('utf-8')
+ title.encode('utf-8') + str(local_id)).digest()
next_entries.add(key)
if key not in current_entries:
set_lib_entry(user, artist, title, local_id=local_id)
# Invalidate entries that are not in the request.
for key, entry in current_entries.iteritems():
if key not in next_entries:
entry.is_valid = False
# Update the user's model.
g.store.flush()
predict.Model(user).generate(g.store)
return helpers.success()
def create():
data = requestJSON(request)
if not all(param in data for param in ("email", "password")):
return error(1, 'Missing email/password.')
email = data['email']
if not emailIsValid(email):
return error(2, 'Invalid e-mail.')
password = data['password']
if not passwordIsValid(password):
return error(3, 'Invalid password')
accountToken = encodeJWT({
'email': email,
'password': password
}, JWT_SECRET_KEY)
try:
newAccount = Account(email, accountToken)
db.session.add(newAccount)
db.session.commit()
return success()
except IntegrityError:
return error(4, 'E-mail already in use.')
def put_new_password(user, gid):
"""Change the password for the group or sets one if there is one.
We must decide if the users already in the group should be prompted for the new password.
"""
try:
password = request.form['password']
except (KeyrError, ValueError):
raise helpers.BadRequest(errors.MISSING_FIELD,
"group password is missing")
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP,
"group does not exist")
if user.id != group.master_id or group.is_automatic:
raise helpers.BadRequest(errors.UNAUTHORIZED,
"not allowed to change group password unless DJ")
group.password = password if (password != '') else None
#event = GroupEvent(user, user, events.PASSWORD, password)
#TODO check if this is correct
#g.store.add(event)
return helpers.success()
def update_user_nickname(user, uid):
"""Assign a nickname to the user."""
helpers.ensure_users_match(user, uid)
try:
user.nickname = request.form['nickname']
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD, "missing nickname")
return helpers.success()
def update_user_group(user, uid):
"""Join or leave a group."""
helpers.ensure_users_match(user, uid)
if request.method == 'DELETE':
if 'gid' in request.args and int(request.args['gid']) != -1:
gid = int(request.args['gid'])
if user.group is not None and user.group_id == gid:
leave_group(user)
else:
# going to notify the app that it was too late
# we are not taking any other action.
return helpers.late_success()
else:
# legacy version: always remove the user from its
# actual group
leave_group(user)
return helpers.success()
try:
gid = int(request.form['gid'])
except:
raise helpers.BadRequest(errors.MISSING_FIELD,
"cannot to parse group ID")
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP,
"group does not exist")
if group.password is not None:
try:
password = request.form['password']
except:
raise helpers.BadRequest(errors.PASSWORD_EXPECTED,
"password expected")
if password != group.password:
raise helpers.Forbidden("received an invalid group password")
if user.group != group:
if user.group is not None:
if user.group.master == user:
# The user was his old group's master.
user.group.master = None
event = GroupEvent(user.group, user, events.LEAVE, None)
g.store.add(event)
user.group = group
event = GroupEvent(group, user, events.JOIN, None)
g.store.add(event)
return helpers.success()
def update_user_nickname(user, uid):
"""Assign a nickname to the user."""
helpers.ensure_users_match(user, uid)
try:
user.nickname = request.form['nickname']
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing nickname")
return helpers.success()
def leave_master(user, gid):
"""Leave the DJ spot."""
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP, "group does not exist")
if group.master != None and group.master != user:
raise helpers.Unauthorized("you are not the master")
group.master = None
return helpers.success()
def leave_master(user, gid):
"""Leave the DJ spot."""
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP,
"group does not exist")
if group.master != None and group.master != user:
raise helpers.Unauthorized("you are not the master")
group.master = None
return helpers.success()
def change_username():
if request.method == 'GET':
return render_template('change_username.html')
else:
old_username = request.form['OUsername']
new_username = request.form['NUsername']
if not _change_username(Old_Username=old_username, New_Username=new_username):
return '<h1>There was a problem changing your username.Try again later!</h1>'
logout()
return success(title='Changed Username!', message="Successfully changed username!", links='login', method='GET', name='Login')
def delete_account():
if request.method == 'GET':
return render_template('delete_account.html')
else:
username = request.form['Username']
password = request.form['Password']
password_hash =generate_password_hash(password, method='pbkdf2:sha256', salt_length=8)
if not _delete_account(Username=username, Password=password_hash):
return '<h1>There was a problem deleting your account!</h1>'
logout()
return success(title='Successfully Deleted!', message='Successfully deleted your account', links='register', method='GET', name='Register')
def update_user_password(user, uid):
"""Update the user's password."""
helpers.ensure_users_match(user, uid)
try:
pw = request.form['password']
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD, "missing password")
if not password.is_good_enough(pw):
raise helpers.BadRequest(errors.INVALID_EMAIL,
"password is not satisfactory")
user.password = password.encrypt(pw)
return helpers.success()
def remove_playlist(uid, plid):
"""
Disables the playlist plid from user uid playlist library.
"""
removed = g.store.find(PllibEntry, (PllibEntry.user == uid) & (PllibEntry.playlist == plid) & PllibEntry.is_valid).one()
if removed is not None and removed:
removed.is_valid = False
g.store.commit()
return helpers.success()
else:
print 'solo_views.remove_playlist: Failed to remove playlist %d for user %d' % (plid, uid)
raise helpers.NotFound(errors.IS_EMPTY, "Failed to find playlist %d for user %d" % (plid, uid))
def register_authentification():
if request.method == 'GET':
return apology("Wrong request method type!")
else:
username = request.form["username"]
password = request.form["password"]
if not user_exists(username):
hashed_password = generate_password_hash(password, method='pbkdf2:sha256', salt_length=8)
add_new_user(Username=username, Hash=hashed_password)
create_user_portfolio(Username=username)
create_user_history(Username=username)
return success(message="Successfully created account!", links="login", method='POST', name='Login')
return "<h1>User already exists</h1>"
def update_user_password(user, uid):
"""Update the user's password."""
helpers.ensure_users_match(user, uid)
try:
pw = request.form['password']
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing password")
if not password.is_good_enough(pw):
raise helpers.BadRequest(errors.INVALID_EMAIL,
"password is not satisfactory")
user.password = password.encrypt(pw)
return helpers.success()
def add_rating(user, uid):
"""Set a rating for the user."""
helpers.ensure_users_match(user, uid)
try:
artist = request.form['artist']
title = request.form['title']
rating = max(1, min(5, int(request.form['rating'])))
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing artist, title or rating")
except ValueError:
raise helpers.BadRequest(errors.INVALID_RATING, "rating is invalid")
set_rating(user, artist, title, rating)
return helpers.success()
def json_query(self, context, request):
""" Query the Searchable Text Catalog only
"""
request = self.request
query = {
"portal_type": self.get_portal_type(request),
"sort_on": self.get_sort_on(request),
"sort_order": self.get_sort_order(request),
"sort_limit": self.get_sort_limit(request),
"SearchableText": self.get_query(request),
}
logger.info("PloneJSONAPI::json_query:query=%r" % query)
results = self.catalog.search(query)
return success("success", **results)
def json_query(self, context, request):
""" Query the Searchable Text Catalog only
"""
request = self.request
query = {
"portal_type": self.get_portal_type(request),
"sort_on": self.get_sort_on(request),
"sort_order": self.get_sort_order(request),
"sort_limit": self.get_sort_limit(request),
"SearchableText": self.get_query(request),
}
logger.info("PloneJSONAPI::json_query:query=%r" % query)
results = self.catalog.search(query)
return success("success", **results)
def add_rating(user, uid):
"""Set a rating for the user."""
helpers.ensure_users_match(user, uid)
try:
artist = request.form['artist']
title = request.form['title']
rating = max(1, min(5, int(request.form['rating'])))
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing artist, title or rating")
except ValueError:
raise helpers.BadRequest(errors.INVALID_RATING,
"rating is invalid")
set_rating(user, artist, title, rating)
return helpers.success()
def update_user_preference(user, uid):
"""Update the user's current preference."""
helpers.ensure_users_match(user, uid)
try:
pref = request.form['pref']
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing taste field")
usertags = g.store.get(UserTags, uid)
if usertags is None:
usertags = UserTags(uid,unicode("[]"),unicode(pref))
g.store.add(usertags)
else:
usertags.preference = pref
return helpers.success()
def json_contents(self, context, request, content=None):
""" Return JSON for all content types
"""
request = self.request
query = {
"sort_on": self.get_sort_on(request),
"portal_type": self.get_portal_type(request),
"sort_order": self.get_sort_order(request),
"sort_limit": self.get_sort_limit(request),
"SearchableText": self.get_query(request),
}
if content is not None:
query.update({"id": content})
results = self.catalog.search(query)
return success("success", **results)
def json_contents(self, context, request, content=None):
""" Return JSON for all content types
"""
request = self.request
query = {
"sort_on": self.get_sort_on(request),
"portal_type": self.get_portal_type(request),
"sort_order": self.get_sort_order(request),
"sort_limit": self.get_sort_limit(request),
"SearchableText": self.get_query(request),
}
if content is not None:
query.update({"id": content})
results = self.catalog.search(query)
return success("success", **results)
def set_master(user, gid):
"""Take the DJ spot (if it is available)."""
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP, "group does not exist")
try:
uid = int(request.form['uid'])
except (KeyError, ValueError):
raise helpers.BadRequest(errors.MISSING_FIELD, "cannot parse uid")
if user.id != uid or user.group != group:
raise helpers.Unauthorized("user not self or not in group")
if group.master != None and group.master != user:
raise helpers.Unauthorized("someone else is already here")
group.master = user
event = GroupEvent(group, user, events.MASTER, None)
g.store.add(event)
return helpers.success()
def change_password():
if request.method == 'GET':
return render_template('change_password.html')
else:
old_password = request.form['OPassword']
new_password = request.form['NPassword']
new_hashed_password = generate_password_hash(new_password, method='pbkdf2:sha256', salt_length=8)
old_hashed_password = generate_password_hash(old_password, method='pbkdf2:sha256', salt_length=8)
rows = db.execute("SELECT * FROM users WHERE username = :username",
username=find_user_with_this_id(session['user_id']))
#validate if old password is correct
if not check_password_hash(rows[0]['hash'], request.form['OPassword']):
# if not checkOldPassword(old_hashed_password):
return '<h1>Old password incorrect!</h1>'
if not _change_password(Old_Hash=old_hashed_password, New_Hash=new_hashed_password):
return '<h1>There was problem changing your password.Try again later!</h1>'
logout()
return success(title='Changed Password!', message='Successfully changed password!', method='GET',name='Login')
def update_user_email(user, uid):
"""Update the user's e-mail address."""
helpers.ensure_users_match(user, uid)
try:
email = request.form['email']
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing e-mail address")
if not mail.is_valid(email):
raise helpers.BadRequest(errors.INVALID_EMAIL, "e-mail is not valid")
try:
user.email = email
g.store.flush()
except storm.exceptions.IntegrityError:
# E-mail already in database.
raise helpers.BadRequest(errors.EXISTING_USER,
"e-mail already taken by another user")
return helpers.success()
def deposit():
data = requestJSON(request)
depositPrep = movementsValidation(data, JWT_SECRET_KEY)
if depositPrep['success'] != True:
return depositPrep
depositValue = depositPrep['movementValue']
account = depositPrep['account']
account.balance += depositValue
account.date_updated = datetime.now()
db.session.commit()
return success()
def set_master(user, gid):
"""Take the DJ spot (if it is available)."""
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP,
"group does not exist")
try:
uid = int(request.form['uid'])
except (KeyError, ValueError):
raise helpers.BadRequest(errors.MISSING_FIELD,
"cannot parse uid")
if user.id != uid or user.group != group:
raise helpers.Unauthorized("user not self or not in group")
if group.master != None and group.master != user:
raise helpers.Unauthorized("someone else is already here")
group.master = user
event = GroupEvent(group, user, events.MASTER, None)
g.store.add(event)
return helpers.success()
def update_user_email(user, uid):
"""Update the user's e-mail address."""
helpers.ensure_users_match(user, uid)
try:
email = request.form['email']
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing e-mail address")
if not mail.is_valid(email):
raise helpers.BadRequest(errors.INVALID_EMAIL,
"e-mail is not valid")
try:
user.email = email
g.store.flush()
except storm.exceptions.IntegrityError:
# E-mail already in database.
raise helpers.BadRequest(errors.EXISTING_USER,
"e-mail already taken by another user")
return helpers.success()
def getSubAndVideosNames(subtitleLink):
print('Checking subtitle in', subtitleLink)
rSubtitle = requests.get(subtitleLink)
subtitlesHTML = rSubtitle.text
print('Checking subtitle name first...')
videosNames = re.findall(r'title=\"Subtitle filename\" \/>(.+)[\n\s\(]+', subtitlesHTML)
videosNames = videosNames + re.findall('title=\"Download - (.+)\" href', subtitlesHTML)
if not videosNames:
print('Videos names were not found!')
return error('Not found!')
return success('names', videosNames)
def reset_password():
"""Send an e-mail containing a link to reset the password."""
try:
email = request.form['email']
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing e-mail address")
user = g.store.find(User, User.email == email).one()
if user is None:
raise helpers.BadRequest(errors.INVALID_USER,
"e-mail address doesn't correspond to any user")
# Send an e-mail with a special link.
msg = reset_password_email(user.id)
try:
# TODO check that it went through.
mail.send(email, "Password reset", msg)
except:
pass
return helpers.success()
def withdraw():
data = requestJSON(request)
withdrawalPrep = movementsValidation(data, JWT_SECRET_KEY)
if withdrawalPrep['success'] != True:
return withdrawalPrep
account = withdrawalPrep['account']
withdrawalValue = withdrawalPrep['movementValue']
if withdrawalValue > account.balance:
return error(11, 'Not enough money.')
account.balance -= withdrawalValue
account.date_updated = datetime.now()
db.session.commit()
return success()
def skip_track(user, gid):
"""Skip the track that is currently being played."""
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP,
"group does not exist")
if group.master != user:
raise helpers.Unauthorized("you are not the master")
results = g.store.find(GroupEvent, (GroupEvent.event_type == events.PLAY)
& (GroupEvent.group == group))
play_event = results.order_by(Desc(GroupEvent.created)).first()
if play_event is None:
raise helpers.BadRequest(errors.NO_CURRENT_TRACK,
"no track to skip")
payload = {
'artist': play_event.payload.get('artist'),
'title': play_event.payload.get('title'),
'master': {'uid': user.id, 'nickname': user.nickname},
}
event = GroupEvent(group, user, events.SKIP, payload)
g.store.add(event)
return helpers.success()
def skip_track(user, gid):
"""Skip the track that is currently being played."""
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP, "group does not exist")
if group.master != user:
raise helpers.Unauthorized("you are not the master")
results = g.store.find(GroupEvent, (GroupEvent.event_type == events.PLAY)
& (GroupEvent.group == group))
play_event = results.order_by(Desc(GroupEvent.created)).first()
if play_event is None:
raise helpers.BadRequest(errors.NO_CURRENT_TRACK, "no track to skip")
payload = {
'artist': play_event.payload.get('artist'),
'title': play_event.payload.get('title'),
'master': {
'uid': user.id,
'nickname': user.nickname
},
}
event = GroupEvent(group, user, events.SKIP, payload)
g.store.add(event)
return helpers.success()
def play_track(user, gid):
"""Register the track that is currently playing."""
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP, "group does not exist")
if group.master != user:
raise helpers.Unauthorized("you are not the master")
try:
artist = request.form['artist']
title = request.form['title']
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing artist and / or title")
track = g.store.find(Track, (Track.artist == artist) &
(Track.title == title)).one()
if track is None:
raise helpers.BadRequest(errors.INVALID_TRACK, "track not found")
payload = {
'artist': track.artist,
'title': track.title,
'master': {
'uid': user.id,
'nickname': user.nickname
},
}
payload['stats'] = list()
# TODO Something better than random scores :)
for resident in group.users:
payload['stats'].append({
'uid': resident.id,
'nickname': resident.nickname,
'score': int(random.random() * 100),
'predicted': True #if random.random() > 0.2 else False
})
event = GroupEvent(group, user, events.PLAY, payload)
g.store.add(event)
return helpers.success()
def play_track(user, gid):
"""Register the track that is currently playing."""
group = g.store.get(Group, gid)
if group is None:
raise helpers.BadRequest(errors.INVALID_GROUP,
"group does not exist")
if group.master != user:
raise helpers.Unauthorized("you are not the master")
try:
artist = request.form['artist']
title = request.form['title']
except KeyError:
raise helpers.BadRequest(errors.MISSING_FIELD,
"missing artist and / or title")
track = g.store.find(Track,
(Track.artist == artist) & (Track.title == title)).one()
if track is None:
raise helpers.BadRequest(errors.INVALID_TRACK,
"track not found")
payload = {
'artist': track.artist,
'title': track.title,
'master': {'uid': user.id, 'nickname': user.nickname},
}
payload['stats'] = list()
# TODO Something better than random scores :)
for resident in group.users:
payload['stats'].append({
'uid': resident.id,
'nickname': resident.nickname,
'score': int(random.random() * 100),
'predicted': True #if random.random() > 0.2 else False
})
event = GroupEvent(group, user, events.PLAY, payload)
g.store.add(event)
return helpers.success()
def queryByHashAndSize(filePath, languageID, server, loginToken):
print('Creating video hash...')
tryVideoHash = hashFile(filePath)
if not tryVideoHash['success']:
print('Could not generate hash.')
return error(tryVideoHash['errorMessage'])
videoHash = tryVideoHash['hash']
videoSize = str(os.path.getsize(filePath))
print('Sucess - Hash:', videoHash, '- Size:', videoSize)
query = [{
'sublanguageid': languageID,
'moviehash': videoHash,
'moviebytesize': videoSize
}]
print('Performing query...')
subtitles = server.SearchSubtitles(loginToken, query)
if 'data' in subtitles and subtitles['data']:
print('A subtitle was found!')
print('Choosing the one with the language id selected...')
correctLanguageSubs = [
sub for sub in subtitles['data']
if sub['SubLanguageID'] == languageID
]
if not correctLanguageSubs:
print('A subtitle for the language ID selected was not found!')
return error(
'A subtitle for the language ID selected was not found!')
print('A subtitle for the language ID selected was found!')
print('Selecting the first one...')
firstSub = correctLanguageSubs[0]
print('The first one:', firstSub)
subDownloadLink = firstSub['SubDownloadLink']
print('Its download link:', subDownloadLink)
return success('downloadLink', subDownloadLink)
else:
print('Nothing was found :(')
return error('No subtitle was found.')
def queryByFileName(fileName, languageID, server, loginToken):
print(
'First looking for movie suggestions with guessed movie name and year.'
)
query = [{'sublanguageid': languageID, 'query': fileName}]
guessQuery = ''
guessedName = guessMovieName(fileName)
if guessedName:
print('Guessed movie name:', guessedName)
guessQuery = guessedName
guessedYear = guessMovieYear(fileName)
if guessedYear:
print('Guessed movie year:', guessedYear)
guessQuery += ' ' + guessedYear
movieID = ''
if guessQuery:
print('Requesting suggestions...')
suggestionsBaseURL = 'https://www.opensubtitles.org/libs/suggest.php?format=json3&MovieName='
suggestionsURL = suggestionsBaseURL + guessQuery.replace(' ', '%20')
rSuggestions = requests.get(suggestionsURL)
moviesList = rSuggestions.json()
if len(moviesList) == 1:
print('Found only one movie. Using its ID.')
movieID = moviesList[0]['id']
if movieID:
query = [{'sublanguageid': languageID, 'idmovie': movieID}]
print('Performing subtitles query...')
queryResponse = server.SearchSubtitles(loginToken, query)
# Try again with guessed movie name and year.
if not 'data' in queryResponse or not queryResponse['data']:
print('No subtitle was found.')
if not guessQuery:
return error(
'Query with file name returned empty, and function could not guess movie name.'
)
print('Trying with guessed movie name and year.')
query = [{'sublanguageid': languageID, 'query': guessQuery}]
queryResponse = server.SearchSubtitles(loginToken, query)
if not 'data' in queryResponse or not queryResponse['data']:
return error('Both queries returned empty.')
print('Success!')
subtitles = queryResponse['data']
similarities = []
chosenSubtitles = []
for sub in subtitles:
tryGetSubAndMoviesNames = getSubAndVideosNames(sub['SubtitlesLink'])
if 'success' not in tryGetSubAndMoviesNames or not tryGetSubAndMoviesNames[
'success']:
continue
videosNames = tryGetSubAndMoviesNames['names']
thisHighestSimilarity = 0
for videoName in videosNames:
print('Calculating similarity for video name:', videoName)
videoSimilarity = SequenceMatcher(None, videoName,
fileName).ratio()
print('Similarity:', videoSimilarity)
if videoSimilarity >= 0.9:
chosenSubtitles.append(sub)
break
if videoSimilarity > thisHighestSimilarity:
thisHighestSimilarity = videoSimilarity
if chosenSubtitles:
break
similarities.append(thisHighestSimilarity)
if not chosenSubtitles:
print('Could not find a perfect match.')
print('Adding the three best matches in the line...')
fixedSimilarities = similarities[:]
similarities.sort(reverse=True)
i = 0
while i < len(similarities) and i < 3:
subIndex = fixedSimilarities.index(similarities[i])
print('Adding subtitle of similarity', similarities[i])
chosenSubtitles.append(subtitles[subIndex])
print('The subtitle link is', subtitles[subIndex]['SubtitlesLink'])
i += 1
if not chosenSubtitles:
print(
'No video name was found, so similarity failed. Using the three best of the query.'
)
i = 0
while i < len(subtitles) and i < 3:
chosenSubtitles.append(subtitles[i])
i += 1
downloadLinks = []
for sub in chosenSubtitles:
downloadLinks.append(sub['SubDownloadLink'])
return success('links', downloadLinks)
def logoutUser():
tokenRepo = UserTokenRepository()
tokenRepo.deleteToken(UserToken, session['token'])
session.clear()
flash(helpers.success('Successfully Logout'))
return redirect('/admin/')
def update_playlist(uid, plid):
"""
Updates the playlist plid from user uid.
Fields to be updted are optional.
Supported fields:
* local_id [int]
* title [Unicode]
* image [Unicode]
* tracks [JSONObject]
* delta [JSONObject]
"""
# Updates are only allowed if user is author of playlist
entry = g.store.find(Playlist, (Playlist.author_id == uid) & (Playlist.id == plid ) & Playlist.is_valid).one()
if entry is not None and entry:
fields = request.form['fields']
if fields:
fields = json.loads(fields)
for field in fields.items():
key = field[0]
value = field[1]
if key == 'title':
entry.set(title=unicode(value))
elif key == 'image':
entry.set(image=unicode(value))
elif key == 'local_id':
if value is not None:
value = int(value)
g.store.find(PllibEntry, (PllibEntry.user_id == uid) & (PllibEntry.playlist_id == plid) & PllibEntry.is_valid).set(local_id=value)
elif key == 'tracks':
entry.set(tracks=value)
elif key == 'delta':
# WORK IN PROGRESS
try:
delta = json.loads(value)
delta_type = delta['type']
artist = delta['entry']['artist']
title = delta['entry']['title']
local_id = int(delta['entry']['local_id'])
play_order = int(delta['entry']['play_order'])
except:
raise helpers.BadRequest(errors.INVALID_DELTA,
"not a valid playlist library delta")
current_entries = local_valid_entries(user)
key = hashlib.sha1(artist.encode('utf-8')
+ title.encode('utf-8') + str(local_id)).digest()
if delta_type == 'PUT':
if key not in current_entries:
set_lib_entry(user, artist, title, local_id=local_id)
elif delta_type == 'DELETE':
if key in current_entries:
current_entries[key].is_valid = False
else:
# Unknown delta type.
print 'solo_views.update_playlist: invalid delta "%s" for playlist %s' % (delta_type, uid)
raise helpers.BadRequest(errors.INVALID_DELTA,
"not a valid library delta")
g.store.commit()
return helpers.success()
print 'solo_views.update_playlist: invalid delta'
raise helpers.NotFound(errors.OPERATION_FAILED, "Failed to update the playlist with id %d, please check if user is author." % uid)
