1274 lines
37 KiB
Python
1274 lines
37 KiB
Python
import time
|
|
from _mysql import ProgrammingError
|
|
|
|
from common import generalUtils
|
|
from common.constants import gameModes
|
|
from common.constants import privileges
|
|
from common.log import logUtils as log
|
|
from common.ripple import passwordUtils, scoreUtils
|
|
from objects import glob
|
|
|
|
|
|
def getUserStats(userID, gameMode):
|
|
"""
|
|
Get all user stats relative to `gameMode`
|
|
|
|
:param userID:
|
|
:param gameMode: game mode number
|
|
:return: dictionary with result
|
|
"""
|
|
modeForDB = gameModes.getGameModeForDB(gameMode)
|
|
|
|
# Get stats
|
|
stats = glob.db.fetch("""SELECT
|
|
ranked_score_{gm} AS rankedScore,
|
|
avg_accuracy_{gm} AS accuracy,
|
|
playcount_{gm} AS playcount,
|
|
total_score_{gm} AS totalScore,
|
|
pp_{gm} AS pp
|
|
FROM users_stats WHERE id = %s LIMIT 1""".format(gm=modeForDB), [userID])
|
|
|
|
# Get game rank
|
|
stats["gameRank"] = getGameRank(userID, gameMode)
|
|
|
|
# Return stats + game rank
|
|
return stats
|
|
|
|
def getUserStatsRx(userID, gameMode):
|
|
"""
|
|
Get all user stats relative to `gameMode`
|
|
|
|
:param userID:
|
|
:param gameMode: game mode number
|
|
:return: dictionary with result
|
|
"""
|
|
modeForDB = gameModes.getGameModeForDB(gameMode)
|
|
|
|
# Get stats
|
|
stats = glob.db.fetch("""SELECT
|
|
ranked_score_{gm} AS rankedScore,
|
|
avg_accuracy_{gm} AS accuracy,
|
|
playcount_{gm} AS playcount,
|
|
total_score_{gm} AS totalScore,
|
|
pp_{gm}_rx AS pp
|
|
FROM users_stats WHERE id = %s LIMIT 1""".format(gm=modeForDB), [userID])
|
|
|
|
# Get game rank
|
|
stats["gameRank"] = getGameRankRx(userID, gameMode)
|
|
|
|
# Return stats + game rank
|
|
return stats
|
|
|
|
def getIDSafe(_safeUsername):
|
|
"""
|
|
Get user ID from a safe username
|
|
:param _safeUsername: safe username
|
|
:return: None if the user doesn't exist, else user id
|
|
"""
|
|
result = glob.db.fetch("SELECT id FROM users WHERE username_safe = %s LIMIT 1", [_safeUsername])
|
|
if result is not None:
|
|
return result["id"]
|
|
return None
|
|
|
|
def getID(username):
|
|
"""
|
|
Get username's user ID from userID redis cache (if cache hit)
|
|
or from db (and cache it for other requests) if cache miss
|
|
|
|
:param username: user
|
|
:return: user id or 0 if user doesn't exist
|
|
"""
|
|
# Get userID from redis
|
|
usernameSafe = safeUsername(username)
|
|
userID = glob.redis.get("ripple:userid_cache:{}".format(usernameSafe))
|
|
|
|
if userID is None:
|
|
# If it's not in redis, get it from mysql
|
|
userID = getIDSafe(usernameSafe)
|
|
|
|
# If it's invalid, return 0
|
|
if userID is None:
|
|
return 0
|
|
|
|
# Otherwise, save it in redis and return it
|
|
glob.redis.set("ripple:userid_cache:{}".format(usernameSafe), userID, 3600) # expires in 1 hour
|
|
return userID
|
|
|
|
# Return userid from redis
|
|
return int(userID)
|
|
|
|
def getUsername(userID):
|
|
"""
|
|
Get userID's username
|
|
|
|
:param userID: user id
|
|
:return: username or None
|
|
"""
|
|
result = glob.db.fetch("SELECT username FROM users WHERE id = %s LIMIT 1", [userID])
|
|
if result is None:
|
|
return None
|
|
return result["username"]
|
|
|
|
def getSafeUsername(userID):
|
|
"""
|
|
Get userID's safe username
|
|
|
|
:param userID: user id
|
|
:return: username or None
|
|
"""
|
|
result = glob.db.fetch("SELECT username_safe FROM users WHERE id = %s LIMIT 1", [userID])
|
|
if result is None:
|
|
return None
|
|
return result["username_safe"]
|
|
|
|
def exists(userID):
|
|
"""
|
|
Check if given userID exists
|
|
|
|
:param userID: user id to check
|
|
:return: True if the user exists, else False
|
|
"""
|
|
return True if glob.db.fetch("SELECT id FROM users WHERE id = %s LIMIT 1", [userID]) is not None else False
|
|
|
|
def checkLogin(userID, password, ip=""):
|
|
"""
|
|
Check userID's login with specified password
|
|
|
|
:param userID: user id
|
|
:param password: md5 password
|
|
:param ip: request IP (used to check active bancho sessions). Optional.
|
|
:return: True if user id and password combination is valid, else False
|
|
"""
|
|
# Check cached bancho session
|
|
banchoSession = False
|
|
if ip != "":
|
|
banchoSession = checkBanchoSession(userID, ip)
|
|
|
|
# Return True if there's a bancho session for this user from that ip
|
|
if banchoSession:
|
|
return True
|
|
|
|
# Otherwise, check password
|
|
# Get password data
|
|
passwordData = glob.db.fetch("SELECT password_md5, salt, password_version FROM users WHERE id = %s LIMIT 1", [userID])
|
|
|
|
# Make sure the query returned something
|
|
if passwordData is None:
|
|
return False
|
|
|
|
# Return valid/invalid based on the password version.
|
|
if passwordData["password_version"] == 2:
|
|
return passwordUtils.checkNewPassword(password, passwordData["password_md5"])
|
|
if passwordData["password_version"] == 1:
|
|
ok = passwordUtils.checkOldPassword(password, passwordData["salt"], passwordData["password_md5"])
|
|
if not ok:
|
|
return False
|
|
newpass = passwordUtils.genBcrypt(password)
|
|
glob.db.execute("UPDATE users SET password_md5=%s, salt='', password_version='2' WHERE id = %s LIMIT 1", [newpass, userID])
|
|
|
|
def getRequiredScoreForLevel(level):
|
|
"""
|
|
Return score required to reach a level
|
|
|
|
:param level: level to reach
|
|
:return: required score
|
|
"""
|
|
if level <= 100:
|
|
if level >= 2:
|
|
return 5000 / 3 * (4 * (level ** 3) - 3 * (level ** 2) - level) + 1.25 * (1.8 ** (level - 60))
|
|
elif level <= 0 or level == 1:
|
|
return 1 # Should be 0, but we get division by 0 below so set to 1
|
|
elif level >= 101:
|
|
return 26931190829 + 100000000000 * (level - 100)
|
|
|
|
def getLevel(totalScore):
|
|
"""
|
|
Return level from totalScore
|
|
|
|
:param totalScore: total score
|
|
:return: level
|
|
"""
|
|
level = 1
|
|
while True:
|
|
# if the level is > 8000, it's probably an endless loop. terminate it.
|
|
if level > 8000:
|
|
return level
|
|
|
|
# Calculate required score
|
|
reqScore = getRequiredScoreForLevel(level)
|
|
|
|
# Check if this is our level
|
|
if totalScore <= reqScore:
|
|
# Our level, return it and break
|
|
return level - 1
|
|
else:
|
|
# Not our level, calculate score for next level
|
|
level += 1
|
|
|
|
def updateLevel(userID, gameMode=0, totalScore=0):
|
|
"""
|
|
Update level in DB for userID relative to gameMode
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:param totalScore: new total score
|
|
:return:
|
|
"""
|
|
# Make sure the user exists
|
|
# if not exists(userID):
|
|
# return
|
|
|
|
# Get total score from db if not passed
|
|
mode = scoreUtils.readableGameMode(gameMode)
|
|
if totalScore == 0:
|
|
totalScore = glob.db.fetch(
|
|
"SELECT total_score_{m} as total_score FROM users_stats WHERE id = %s LIMIT 1".format(m=mode), [userID])
|
|
if totalScore:
|
|
totalScore = totalScore["total_score"]
|
|
|
|
# Calculate level from totalScore
|
|
level = getLevel(totalScore)
|
|
|
|
# Save new level
|
|
glob.db.execute("UPDATE users_stats SET level_{m} = %s WHERE id = %s LIMIT 1".format(m=mode), [level, userID])
|
|
|
|
def calculateAccuracy(userID, gameMode):
|
|
"""
|
|
Calculate accuracy value for userID relative to gameMode
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return: new accuracy
|
|
"""
|
|
# Select what to sort by
|
|
if gameMode == 0:
|
|
sortby = "pp"
|
|
else:
|
|
sortby = "accuracy"
|
|
# Get best accuracy scores
|
|
bestAccScores = glob.db.fetchAll(
|
|
"SELECT accuracy FROM scores WHERE userid = %s AND play_mode = %s AND completed = 3 ORDER BY " + sortby + " DESC LIMIT 500",
|
|
[userID, gameMode])
|
|
|
|
v = 0
|
|
if bestAccScores is not None:
|
|
# Calculate weighted accuracy
|
|
totalAcc = 0
|
|
divideTotal = 0
|
|
k = 0
|
|
for i in bestAccScores:
|
|
add = int((0.95 ** k) * 100)
|
|
totalAcc += i["accuracy"] * add
|
|
divideTotal += add
|
|
k += 1
|
|
# echo "$add - $totalacc - $divideTotal\n"
|
|
if divideTotal != 0:
|
|
v = totalAcc / divideTotal
|
|
else:
|
|
v = 0
|
|
return v
|
|
|
|
def calculatePP(userID, gameMode):
|
|
"""
|
|
Calculate userID's total PP for gameMode
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return: total PP
|
|
"""
|
|
# Get best pp scores
|
|
bestPPScores = glob.db.fetchAll(
|
|
"SELECT pp FROM scores WHERE userid = %s AND play_mode = %s AND completed = 3 ORDER BY pp DESC LIMIT 500",
|
|
[userID, gameMode])
|
|
|
|
# Calculate weighted PP
|
|
totalPP = 0
|
|
if bestPPScores is not None:
|
|
k = 0
|
|
for i in bestPPScores:
|
|
new = round(round(i["pp"]) * 0.95 ** k)
|
|
totalPP += new
|
|
k += 1
|
|
|
|
return totalPP
|
|
|
|
def calculatePPRelax(userID, gameMode):
|
|
"""
|
|
Calculate userID's total PP for gameMode
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return: total PP
|
|
"""
|
|
# Get best pp scores
|
|
bestPPScores = glob.db.fetchAll(
|
|
"SELECT pp FROM scores_relax WHERE userid = %s AND play_mode = %s AND completed = 3 ORDER BY pp DESC LIMIT 500",
|
|
[userID, gameMode])
|
|
|
|
# Calculate weighted PP
|
|
totalPP = 0
|
|
if bestPPScores is not None:
|
|
k = 0
|
|
for i in bestPPScores:
|
|
new = round(round(i["pp"]) * 0.95 ** k)
|
|
totalPP += new
|
|
k += 1
|
|
|
|
return totalPP
|
|
def updateAccuracy(userID, gameMode):
|
|
"""
|
|
Update accuracy value for userID relative to gameMode in DB
|
|
|
|
:param userID: user id
|
|
:param gameMode: gameMode number
|
|
:return:
|
|
"""
|
|
newAcc = calculateAccuracy(userID, gameMode)
|
|
mode = scoreUtils.readableGameMode(gameMode)
|
|
glob.db.execute("UPDATE users_stats SET avg_accuracy_{m} = %s WHERE id = %s LIMIT 1".format(m=mode),
|
|
[newAcc, userID])
|
|
|
|
def updatePP(userID, gameMode):
|
|
"""
|
|
Update userID's pp with new value
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
"""
|
|
# Make sure the user exists
|
|
# if not exists(userID):
|
|
# return
|
|
|
|
# Get new total PP and update db
|
|
newPP = calculatePP(userID, gameMode)
|
|
mode = scoreUtils.readableGameMode(gameMode)
|
|
glob.db.execute("UPDATE users_stats SET pp_{}=%s WHERE id = %s LIMIT 1".format(mode), [newPP, userID])
|
|
|
|
|
|
def updatePPRelax(userID, gameMode):
|
|
"""
|
|
Update userID's pp with new value
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
"""
|
|
# Make sure the user exists
|
|
# if not exists(userID):
|
|
# return
|
|
|
|
# Get new total PP and update db
|
|
newPP = calculatePPRelax(userID, gameMode)
|
|
mode = scoreUtils.readableGameMode(gameMode)
|
|
glob.db.execute("UPDATE users_stats SET pp_{}_rx=%s WHERE id = %s LIMIT 1".format(mode), [newPP, userID])
|
|
|
|
def updateStats(userID, __score):
|
|
"""
|
|
Update stats (playcount, total score, ranked score, level bla bla)
|
|
with data relative to a score object
|
|
|
|
:param userID:
|
|
:param __score: score object
|
|
"""
|
|
|
|
# Make sure the user exists
|
|
if not exists(userID):
|
|
log.warning("User {} doesn't exist.".format(userID))
|
|
return
|
|
|
|
# Get gamemode for db
|
|
mode = scoreUtils.readableGameMode(__score.gameMode)
|
|
|
|
# Update total score and playcount
|
|
glob.db.execute(
|
|
"UPDATE users_stats SET total_score_{m}=total_score_{m}+%s, playcount_{m}=playcount_{m}+1 WHERE id = %s LIMIT 1".format(
|
|
m=mode), [__score.score, userID])
|
|
|
|
# Calculate new level and update it
|
|
updateLevel(userID, __score.gameMode)
|
|
|
|
# Update level, accuracy and ranked score only if we have passed the song
|
|
if __score.passed:
|
|
# Update ranked score
|
|
glob.db.execute(
|
|
"UPDATE users_stats SET ranked_score_{m}=ranked_score_{m}+%s WHERE id = %s LIMIT 1".format(m=mode),
|
|
[__score.rankedScoreIncrease, userID])
|
|
|
|
# Update accuracy
|
|
updateAccuracy(userID, __score.gameMode)
|
|
|
|
# Update pp
|
|
updatePP(userID, __score.gameMode)
|
|
|
|
def updateStatsRx(userID, __score):
|
|
"""
|
|
Update stats (playcount, total score, ranked score, level bla bla)
|
|
with data relative to a score object
|
|
|
|
:param userID:
|
|
:param __score: score object
|
|
"""
|
|
|
|
# Make sure the user exists
|
|
if not exists(userID):
|
|
log.warning("User {} doesn't exist.".format(userID))
|
|
return
|
|
|
|
# Get gamemode for db
|
|
mode = scoreUtils.readableGameMode(__score.gameMode)
|
|
|
|
# Update total score and playcount
|
|
glob.db.execute(
|
|
"UPDATE users_stats SET total_score_{m}=total_score_{m}+%s, playcount_{m}=playcount_{m}+1 WHERE id = %s LIMIT 1".format(
|
|
m=mode), [__score.score, userID])
|
|
|
|
# Calculate new level and update it
|
|
updateLevel(userID, __score.gameMode)
|
|
|
|
# Update level, accuracy and ranked score only if we have passed the song
|
|
if __score.passed:
|
|
# Update ranked score
|
|
glob.db.execute(
|
|
"UPDATE users_stats SET ranked_score_{m}=ranked_score_{m}+%s WHERE id = %s LIMIT 1".format(m=mode),
|
|
[__score.rankedScoreIncrease, userID])
|
|
|
|
# Update accuracy
|
|
updateAccuracy(userID, __score.gameMode)
|
|
|
|
# Update pp
|
|
updatePPRelax(userID, __score.gameMode)
|
|
|
|
def updateLatestActivity(userID):
|
|
"""
|
|
Update userID's latest activity to current UNIX time
|
|
|
|
:param userID: user id
|
|
:return:
|
|
"""
|
|
glob.db.execute("UPDATE users SET latest_activity = %s WHERE id = %s LIMIT 1", [int(time.time()), userID])
|
|
|
|
def getRankedScore(userID, gameMode):
|
|
"""
|
|
Get userID's ranked score relative to gameMode
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return: ranked score
|
|
"""
|
|
mode = scoreUtils.readableGameMode(gameMode)
|
|
result = glob.db.fetch("SELECT ranked_score_{} FROM users_stats WHERE id = %s LIMIT 1".format(mode), [userID])
|
|
if result is not None:
|
|
return result["ranked_score_{}".format(mode)]
|
|
else:
|
|
return 0
|
|
|
|
def getPP(userID, gameMode):
|
|
"""
|
|
Get userID's PP relative to gameMode
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return: pp
|
|
"""
|
|
|
|
mode = scoreUtils.readableGameMode(gameMode)
|
|
result = glob.db.fetch("SELECT pp_{} FROM users_stats WHERE id = %s LIMIT 1".format(mode), [userID])
|
|
if result is not None:
|
|
return result["pp_{}".format(mode)]
|
|
else:
|
|
return 0
|
|
|
|
def incrementReplaysWatched(userID, gameMode):
|
|
"""
|
|
Increment userID's replays watched by others relative to gameMode
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return:
|
|
"""
|
|
mode = scoreUtils.readableGameMode(gameMode)
|
|
glob.db.execute(
|
|
"UPDATE users_stats SET replays_watched_{mode}=replays_watched_{mode}+1 WHERE id = %s LIMIT 1".format(
|
|
mode=mode), [userID])
|
|
|
|
def getAqn(userID):
|
|
"""
|
|
Check if AQN folder was detected for userID
|
|
|
|
:param userID: user
|
|
:return: True if hax, False if legit
|
|
"""
|
|
result = glob.db.fetch("SELECT aqn FROM users WHERE id = %s LIMIT 1", [userID])
|
|
if result is not None:
|
|
return True if int(result["aqn"]) == 1 else False
|
|
else:
|
|
return False
|
|
|
|
def setAqn(userID, value=1):
|
|
"""
|
|
Set AQN folder status for userID
|
|
|
|
:param userID: user
|
|
:param value: new aqn value, default = 1
|
|
:return:
|
|
"""
|
|
glob.db.fetch("UPDATE users SET aqn = %s WHERE id = %s LIMIT 1", [value, userID])
|
|
|
|
def IPLog(userID, ip):
|
|
"""
|
|
Log user IP
|
|
|
|
:param userID: user id
|
|
:param ip: IP address
|
|
:return:
|
|
"""
|
|
glob.db.execute("""INSERT INTO ip_user (userid, ip, occurencies) VALUES (%s, %s, '1')
|
|
ON DUPLICATE KEY UPDATE occurencies = occurencies + 1""", [userID, ip])
|
|
|
|
def checkBanchoSession(userID, ip=""):
|
|
"""
|
|
Return True if there is a bancho session for `userID` from `ip`
|
|
If `ip` is an empty string, check if there's a bancho session for that user, from any IP.
|
|
|
|
:param userID: user id
|
|
:param ip: ip address. Optional. Default: empty string
|
|
:return: True if there's an active bancho session, else False
|
|
"""
|
|
if ip != "":
|
|
return glob.redis.sismember("peppy:sessions:{}".format(userID), ip)
|
|
else:
|
|
return glob.redis.exists("peppy:sessions:{}".format(userID))
|
|
|
|
def is2FAEnabled(userID):
|
|
"""
|
|
Returns True if 2FA/Google auth 2FA is enable for `userID`
|
|
|
|
:userID: user ID
|
|
:return: True if 2fa is enabled, else False
|
|
"""
|
|
return glob.db.fetch("SELECT 2fa_totp.userid FROM 2fa_totp WHERE userid = %(userid)s AND enabled = 1 LIMIT 1", {
|
|
"userid": userID
|
|
}) is not None
|
|
|
|
def check2FA(userID, ip):
|
|
"""
|
|
Returns True if this IP is untrusted.
|
|
Returns always False if 2fa is not enabled on `userID`
|
|
|
|
:param userID: user id
|
|
:param ip: IP address
|
|
:return: True if untrusted, False if trusted or 2fa is disabled.
|
|
"""
|
|
if not is2FAEnabled(userID):
|
|
return False
|
|
|
|
result = glob.db.fetch("SELECT id FROM ip_user WHERE userid = %s AND ip = %s", [userID, ip])
|
|
return True if result is None else False
|
|
|
|
def isAllowed(userID):
|
|
"""
|
|
Check if userID is not banned or restricted
|
|
|
|
:param userID: user id
|
|
:return: True if not banned or restricted, otherwise false.
|
|
"""
|
|
result = glob.db.fetch("SELECT privileges FROM users WHERE id = %s LIMIT 1", [userID])
|
|
if result is not None:
|
|
return (result["privileges"] & privileges.USER_NORMAL) and (result["privileges"] & privileges.USER_PUBLIC)
|
|
else:
|
|
return False
|
|
|
|
def isRestricted(userID):
|
|
"""
|
|
Check if userID is restricted
|
|
|
|
:param userID: user id
|
|
:return: True if not restricted, otherwise false.
|
|
"""
|
|
result = glob.db.fetch("SELECT privileges FROM users WHERE id = %s LIMIT 1", [userID])
|
|
if result is not None:
|
|
return (result["privileges"] & privileges.USER_NORMAL) and not (result["privileges"] & privileges.USER_PUBLIC)
|
|
else:
|
|
return False
|
|
|
|
def isBanned(userID):
|
|
"""
|
|
Check if userID is banned
|
|
|
|
:param userID: user id
|
|
:return: True if not banned, otherwise false.
|
|
"""
|
|
result = glob.db.fetch("SELECT privileges FROM users WHERE id = %s LIMIT 1", [userID])
|
|
if result is not None:
|
|
return not (result["privileges"] & 3 > 0)
|
|
else:
|
|
return True
|
|
|
|
def isLocked(userID):
|
|
"""
|
|
Check if userID is locked
|
|
|
|
:param userID: user id
|
|
:return: True if not locked, otherwise false.
|
|
"""
|
|
result = glob.db.fetch("SELECT privileges FROM users WHERE id = %s LIMIT 1", [userID])
|
|
if result is not None:
|
|
return (
|
|
(result["privileges"] & privileges.USER_PUBLIC > 0) and (result["privileges"] & privileges.USER_NORMAL == 0))
|
|
else:
|
|
return True
|
|
|
|
def ban(userID):
|
|
"""
|
|
Ban userID
|
|
|
|
:param userID: user id
|
|
:return:
|
|
"""
|
|
# Set user as banned in db
|
|
banDateTime = int(time.time())
|
|
glob.db.execute("UPDATE users SET privileges = privileges & %s, ban_datetime = %s WHERE id = %s LIMIT 1",
|
|
[~(privileges.USER_NORMAL | privileges.USER_PUBLIC), banDateTime, userID])
|
|
|
|
# Notify bancho about the ban
|
|
glob.redis.publish("peppy:ban", userID)
|
|
|
|
# Remove the user from global and country leaderboards
|
|
removeFromLeaderboard(userID)
|
|
|
|
def unban(userID):
|
|
"""
|
|
Unban userID
|
|
|
|
:param userID: user id
|
|
:return:
|
|
"""
|
|
glob.db.execute("UPDATE users SET privileges = privileges | %s, ban_datetime = 0 WHERE id = %s LIMIT 1",
|
|
[(privileges.USER_NORMAL | privileges.USER_PUBLIC), userID])
|
|
glob.redis.publish("peppy:ban", userID)
|
|
|
|
def restrict(userID):
|
|
"""
|
|
Restrict userID
|
|
|
|
:param userID: user id
|
|
:return:
|
|
"""
|
|
if not isRestricted(userID):
|
|
# Set user as restricted in db
|
|
banDateTime = int(time.time())
|
|
glob.db.execute("UPDATE users SET privileges = privileges & %s, ban_datetime = %s WHERE id = %s LIMIT 1",
|
|
[~privileges.USER_PUBLIC, banDateTime, userID])
|
|
|
|
# Notify bancho about this ban
|
|
glob.redis.publish("peppy:ban", userID)
|
|
|
|
# Remove the user from global and country leaderboards
|
|
removeFromLeaderboard(userID)
|
|
|
|
def unrestrict(userID):
|
|
"""
|
|
Unrestrict userID.
|
|
Same as unban().
|
|
|
|
:param userID: user id
|
|
:return:
|
|
"""
|
|
unban(userID)
|
|
|
|
def appendNotes(userID, notes, addNl=True, trackDate=True):
|
|
"""
|
|
Append `notes` to `userID`'s "notes for CM"
|
|
|
|
:param userID: user id
|
|
:param notes: text to append
|
|
:param addNl: if True, prepend \n to notes. Default: True.
|
|
:param trackDate: if True, prepend date and hour to the note. Default: True.
|
|
:return:
|
|
"""
|
|
if trackDate:
|
|
notes = "[{}] {}".format(generalUtils.getTimestamp(), notes)
|
|
if addNl:
|
|
notes = "\n{}".format(notes)
|
|
glob.db.execute("UPDATE users SET notes=CONCAT(COALESCE(notes, ''),%s) WHERE id = %s LIMIT 1", [notes, userID])
|
|
|
|
def getPrivileges(userID):
|
|
"""
|
|
Return `userID`'s privileges
|
|
|
|
:param userID: user id
|
|
:return: privileges number
|
|
"""
|
|
result = glob.db.fetch("SELECT privileges FROM users WHERE id = %s LIMIT 1", [userID])
|
|
if result is not None:
|
|
return result["privileges"]
|
|
else:
|
|
return 0
|
|
|
|
def getSilenceEnd(userID):
|
|
"""
|
|
Get userID's **ABSOLUTE** silence end UNIX time
|
|
Remember to subtract time.time() if you want to get the actual silence time
|
|
|
|
:param userID: user id
|
|
:return: UNIX time
|
|
"""
|
|
return glob.db.fetch("SELECT silence_end FROM users WHERE id = %s LIMIT 1", [userID])["silence_end"]
|
|
|
|
def silence(userID, seconds, silenceReason, author = 999):
|
|
"""
|
|
Silence someone
|
|
|
|
:param userID: user id
|
|
:param seconds: silence length in seconds
|
|
:param silenceReason: silence reason shown on website
|
|
:param author: userID of who silenced the user. Default: 999
|
|
:return:
|
|
"""
|
|
# db qurey
|
|
silenceEndTime = int(time.time())+seconds
|
|
glob.db.execute("UPDATE users SET silence_end = %s, silence_reason = %s WHERE id = %s LIMIT 1", [silenceEndTime, silenceReason, userID])
|
|
|
|
# Log
|
|
targetUsername = getUsername(userID)
|
|
# TODO: exists check im drunk rn i need to sleep (stampa piede ubriaco confirmed)
|
|
if seconds > 0:
|
|
log.rap(author, "has silenced {} for {} seconds for the following reason: \"{}\"".format(targetUsername, seconds, silenceReason), True)
|
|
else:
|
|
log.rap(author, "has removed {}'s silence".format(targetUsername), True)
|
|
|
|
def getTotalScore(userID, gameMode):
|
|
"""
|
|
Get `userID`'s total score relative to `gameMode`
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return: total score
|
|
"""
|
|
modeForDB = gameModes.getGameModeForDB(gameMode)
|
|
return glob.db.fetch("SELECT total_score_"+modeForDB+" FROM users_stats WHERE id = %s LIMIT 1", [userID])["total_score_"+modeForDB]
|
|
|
|
def getAccuracy(userID, gameMode):
|
|
"""
|
|
Get `userID`'s average accuracy relative to `gameMode`
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return: accuracy
|
|
"""
|
|
modeForDB = gameModes.getGameModeForDB(gameMode)
|
|
return glob.db.fetch("SELECT avg_accuracy_"+modeForDB+" FROM users_stats WHERE id = %s LIMIT 1", [userID])["avg_accuracy_"+modeForDB]
|
|
|
|
def getGameRank(userID, gameMode):
|
|
"""
|
|
Get `userID`'s **in-game rank** (eg: #1337) relative to gameMode
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return: game rank
|
|
"""
|
|
position = glob.redis.zrevrank("ripple:leaderboard:{}".format(gameModes.getGameModeForDB(gameMode)), userID)
|
|
if position is None:
|
|
return 0
|
|
else:
|
|
return int(position) + 1
|
|
|
|
def getGameRankRx(userID, gameMode):
|
|
"""
|
|
Get `userID`'s **in-game rank** (eg: #1337) relative to gameMode
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return: game rank
|
|
"""
|
|
position = glob.redis.zrevrank("ripple:leaderboard_relax:{}".format(gameModes.getGameModeForDB(gameMode)), userID)
|
|
if position is None:
|
|
return 0
|
|
else:
|
|
return int(position) + 1
|
|
|
|
def getPlaycount(userID, gameMode):
|
|
"""
|
|
Get `userID`'s playcount relative to `gameMode`
|
|
|
|
:param userID: user id
|
|
:param gameMode: game mode number
|
|
:return: playcount
|
|
"""
|
|
modeForDB = gameModes.getGameModeForDB(gameMode)
|
|
return glob.db.fetch("SELECT playcount_"+modeForDB+" FROM users_stats WHERE id = %s LIMIT 1", [userID])["playcount_"+modeForDB]
|
|
|
|
def getFriendList(userID):
|
|
"""
|
|
Get `userID`'s friendlist
|
|
|
|
:param userID: user id
|
|
:return: list with friends userIDs. [0] if no friends.
|
|
"""
|
|
# Get friends from db
|
|
friends = glob.db.fetchAll("SELECT user2 FROM users_relationships WHERE user1 = %s", [userID])
|
|
|
|
if friends is None or len(friends) == 0:
|
|
# We have no friends, return 0 list
|
|
return [0]
|
|
else:
|
|
# Get only friends
|
|
friends = [i["user2"] for i in friends]
|
|
|
|
# Return friend IDs
|
|
return friends
|
|
|
|
def addFriend(userID, friendID):
|
|
"""
|
|
Add `friendID` to `userID`'s friend list
|
|
|
|
:param userID: user id
|
|
:param friendID: new friend
|
|
:return:
|
|
"""
|
|
# Make sure we aren't adding us to our friends
|
|
if userID == friendID:
|
|
return
|
|
|
|
# check user isn't already a friend of ours
|
|
if glob.db.fetch("SELECT id FROM users_relationships WHERE user1 = %s AND user2 = %s LIMIT 1", [userID, friendID]) is not None:
|
|
return
|
|
|
|
# Set new value
|
|
glob.db.execute("INSERT INTO users_relationships (user1, user2) VALUES (%s, %s)", [userID, friendID])
|
|
|
|
def removeFriend(userID, friendID):
|
|
"""
|
|
Remove `friendID` from `userID`'s friend list
|
|
|
|
:param userID: user id
|
|
:param friendID: old friend
|
|
:return:
|
|
"""
|
|
# Delete user relationship. We don't need to check if the relationship was there, because who gives a shit,
|
|
# if they were not friends and they don't want to be anymore, be it. ¯\_(ツ)_/¯
|
|
# TODO: LIMIT 1
|
|
glob.db.execute("DELETE FROM users_relationships WHERE user1 = %s AND user2 = %s", [userID, friendID])
|
|
|
|
|
|
def getCountry(userID):
|
|
"""
|
|
Get `userID`'s country **(two letters)**.
|
|
|
|
:param userID: user id
|
|
:return: country code (two letters)
|
|
"""
|
|
return glob.db.fetch("SELECT country FROM users_stats WHERE id = %s LIMIT 1", [userID])["country"]
|
|
|
|
def setCountry(userID, country):
|
|
"""
|
|
Set userID's country
|
|
|
|
:param userID: user id
|
|
:param country: country letters
|
|
:return:
|
|
"""
|
|
glob.db.execute("UPDATE users_stats SET country = %s WHERE id = %s LIMIT 1", [country, userID])
|
|
|
|
def logIP(userID, ip):
|
|
"""
|
|
User IP log
|
|
USED FOR MULTIACCOUNT DETECTION
|
|
|
|
:param userID: user id
|
|
:param ip: IP address
|
|
:return:
|
|
"""
|
|
glob.db.execute("""INSERT INTO ip_user (userid, ip, occurencies) VALUES (%s, %s, 1)
|
|
ON DUPLICATE KEY UPDATE occurencies = occurencies + 1""", [userID, ip])
|
|
|
|
def saveBanchoSession(userID, ip):
|
|
"""
|
|
Save userid and ip of this token in redis
|
|
Used to cache logins on LETS requests
|
|
|
|
:param userID: user ID
|
|
:param ip: IP address
|
|
:return:
|
|
"""
|
|
glob.redis.sadd("peppy:sessions:{}".format(userID), ip)
|
|
|
|
def deleteBanchoSessions(userID, ip):
|
|
"""
|
|
Delete this bancho session from redis
|
|
|
|
:param userID: user id
|
|
:param ip: IP address
|
|
:return:
|
|
"""
|
|
glob.redis.srem("peppy:sessions:{}".format(userID), ip)
|
|
|
|
def setPrivileges(userID, priv):
|
|
"""
|
|
Set userID's privileges in db
|
|
|
|
:param userID: user id
|
|
:param priv: privileges number
|
|
:return:
|
|
"""
|
|
glob.db.execute("UPDATE users SET privileges = %s WHERE id = %s LIMIT 1", [priv, userID])
|
|
|
|
def getGroupPrivileges(groupName):
|
|
"""
|
|
Returns the privileges number of a group, by its name
|
|
|
|
:param groupName: name of the group
|
|
:return: privilege integer or `None` if the group doesn't exist
|
|
"""
|
|
groupPrivileges = glob.db.fetch("SELECT privileges FROM privileges_groups WHERE name = %s LIMIT 1", [groupName])
|
|
if groupPrivileges is None:
|
|
return None
|
|
return groupPrivileges["privileges"]
|
|
|
|
def isInPrivilegeGroup(userID, groupName):
|
|
"""
|
|
Check if `userID` is in a privilege group.
|
|
Donor privilege is ignored while checking for groups.
|
|
|
|
:param userID: user id
|
|
:param groupName: privilege group name
|
|
:return: True if `userID` is in `groupName`, else False
|
|
"""
|
|
groupPrivileges = getGroupPrivileges(groupName)
|
|
if groupPrivileges is None:
|
|
return False
|
|
try:
|
|
userToken = glob.tokens.getTokenFromUserID(userID)
|
|
except AttributeError:
|
|
# LETS compatibility
|
|
userToken = None
|
|
|
|
if userToken is not None:
|
|
userPrivileges = userToken.privileges
|
|
else:
|
|
userPrivileges = getPrivileges(userID)
|
|
return userPrivileges & groupPrivileges == groupPrivileges
|
|
|
|
def isInAnyPrivilegeGroup(userID, groups):
|
|
"""
|
|
Checks if a user is in at least one of the specified groups
|
|
|
|
:param userID: id of the user
|
|
:param groups: groups list or tuple
|
|
:return: `True` if `userID` is in at least one of the specified groups, otherwise `False`
|
|
"""
|
|
userPrivileges = getPrivileges(userID)
|
|
return any(
|
|
userPrivileges & x == x
|
|
for x in (
|
|
getGroupPrivileges(y) for y in groups
|
|
) if x is not None
|
|
)
|
|
|
|
def logHardware(userID, hashes, activation = False):
|
|
"""
|
|
Hardware log
|
|
USED FOR MULTIACCOUNT DETECTION
|
|
|
|
|
|
:param userID: user id
|
|
:param hashes: Peppy's botnet (client data) structure (new line = "|", already split)
|
|
[0] osu! version
|
|
[1] plain mac addressed, separated by "."
|
|
[2] mac addresses hash set
|
|
[3] unique ID
|
|
[4] disk ID
|
|
:param activation: if True, set this hash as used for activation. Default: False.
|
|
:return: True if hw is not banned, otherwise false
|
|
"""
|
|
# Make sure the strings are not empty
|
|
for i in hashes[2:5]:
|
|
if i == "":
|
|
log.warning("Invalid hash set ({}) for user {} in HWID check".format(hashes, userID), "bunk")
|
|
return False
|
|
|
|
# Run some HWID checks on that user if he is not restricted
|
|
if not isRestricted(userID):
|
|
# Get username
|
|
username = getUsername(userID)
|
|
|
|
# Get the list of banned or restricted users that have logged in from this or similar HWID hash set
|
|
if hashes[2] == "b4ec3c4334a0249dae95c284ec5983df":
|
|
# Running under wine, check by unique id
|
|
log.debug("Logging Linux/Mac hardware")
|
|
banned = glob.db.fetchAll("""SELECT users.id as userid, hw_user.occurencies, users.username FROM hw_user
|
|
LEFT JOIN users ON users.id = hw_user.userid
|
|
WHERE hw_user.userid != %(userid)s
|
|
AND hw_user.unique_id = %(uid)s
|
|
AND (users.privileges & 3 != 3)""", {
|
|
"userid": userID,
|
|
"uid": hashes[3],
|
|
})
|
|
else:
|
|
# Running under windows, do all checks
|
|
log.debug("Logging Windows hardware")
|
|
banned = glob.db.fetchAll("""SELECT users.id as userid, hw_user.occurencies, users.username FROM hw_user
|
|
LEFT JOIN users ON users.id = hw_user.userid
|
|
WHERE hw_user.userid != %(userid)s
|
|
AND hw_user.mac = %(mac)s
|
|
AND hw_user.unique_id = %(uid)s
|
|
AND hw_user.disk_id = %(diskid)s
|
|
AND (users.privileges & 3 != 3)""", {
|
|
"userid": userID,
|
|
"mac": hashes[2],
|
|
"uid": hashes[3],
|
|
"diskid": hashes[4],
|
|
})
|
|
|
|
for i in banned:
|
|
# Get the total numbers of logins
|
|
total = glob.db.fetch("SELECT COUNT(*) AS count FROM hw_user WHERE userid = %s LIMIT 1", [userID])
|
|
# and make sure it is valid
|
|
if total is None:
|
|
continue
|
|
total = total["count"]
|
|
|
|
# Calculate 10% of total
|
|
perc = (total*10)/100
|
|
|
|
if i["occurencies"] >= perc:
|
|
# If the banned user has logged in more than 10% of the times from this user, restrict this user
|
|
restrict(userID)
|
|
appendNotes(userID, "Logged in from HWID ({hwid}) used more than 10% from user {banned} ({bannedUserID}), who is banned/restricted.".format(
|
|
hwid=hashes[2:5],
|
|
banned=i["username"],
|
|
bannedUserID=i["userid"]
|
|
))
|
|
log.warning("**{user}** ({userID}) has been restricted because he has logged in from HWID _({hwid})_ used more than 10% from banned/restricted user **{banned}** ({bannedUserID}), **possible multiaccount**.".format(
|
|
user=username,
|
|
userID=userID,
|
|
hwid=hashes[2:5],
|
|
banned=i["username"],
|
|
bannedUserID=i["userid"]
|
|
), "cm")
|
|
|
|
# Update hash set occurencies
|
|
glob.db.execute("""
|
|
INSERT INTO hw_user (id, userid, mac, unique_id, disk_id, occurencies) VALUES (NULL, %s, %s, %s, %s, 1)
|
|
ON DUPLICATE KEY UPDATE occurencies = occurencies + 1
|
|
""", [userID, hashes[2], hashes[3], hashes[4]])
|
|
|
|
# Optionally, set this hash as 'used for activation'
|
|
if activation:
|
|
glob.db.execute("UPDATE hw_user SET activated = 1 WHERE userid = %s AND mac = %s AND unique_id = %s AND disk_id = %s", [userID, hashes[2], hashes[3], hashes[4]])
|
|
|
|
# Access granted, abbiamo impiegato 3 giorni
|
|
# We grant access even in case of login from banned HWID
|
|
# because we call restrict() above so there's no need to deny the access.
|
|
return True
|
|
|
|
|
|
def resetPendingFlag(userID, success=True):
|
|
"""
|
|
Remove pending flag from an user.
|
|
|
|
:param userID: user id
|
|
:param success: if True, set USER_PUBLIC and USER_NORMAL flags too
|
|
"""
|
|
glob.db.execute("UPDATE users SET privileges = privileges & %s WHERE id = %s LIMIT 1", [~privileges.USER_PENDING_VERIFICATION, userID])
|
|
if success:
|
|
glob.db.execute("UPDATE users SET privileges = privileges | %s WHERE id = %s LIMIT 1", [(privileges.USER_PUBLIC | privileges.USER_NORMAL), userID])
|
|
|
|
def verifyUser(userID, hashes):
|
|
"""
|
|
Activate `userID`'s account.
|
|
|
|
:param userID: user id
|
|
:param hashes: Peppy's botnet (client data) structure (new line = "|", already split)
|
|
[0] osu! version
|
|
[1] plain mac addressed, separated by "."
|
|
[2] mac addresses hash set
|
|
[3] unique ID
|
|
[4] disk ID
|
|
:return: True if verified successfully, else False (multiaccount)
|
|
"""
|
|
# Check for valid hash set
|
|
for i in hashes[2:5]:
|
|
if i == "":
|
|
log.warning("Invalid hash set ({}) for user {} while verifying the account".format(str(hashes), userID), "bunk")
|
|
return False
|
|
|
|
# Get username
|
|
username = getUsername(userID)
|
|
|
|
# Make sure there are no other accounts activated with this exact mac/unique id/hwid
|
|
if hashes[2] == "b4ec3c4334a0249dae95c284ec5983df" or hashes[4] == "ffae06fb022871fe9beb58b005c5e21d":
|
|
# Running under wine, check only by uniqueid
|
|
log.info("{user} ({userID}) ha triggerato Sannino:\n**Full data:** {hashes}\n**Usual wine mac address hash:** b4ec3c4334a0249dae95c284ec5983df\n**Usual wine disk id:** ffae06fb022871fe9beb58b005c5e21d".format(user=username, userID=userID, hashes=hashes), "bunker")
|
|
log.debug("Veryfing with Linux/Mac hardware")
|
|
match = glob.db.fetchAll("SELECT userid FROM hw_user WHERE unique_id = %(uid)s AND userid != %(userid)s AND activated = 1 LIMIT 1", {
|
|
"uid": hashes[3],
|
|
"userid": userID
|
|
})
|
|
else:
|
|
# Running under windows, full check
|
|
log.debug("Veryfing with Windows hardware")
|
|
match = glob.db.fetchAll("SELECT userid FROM hw_user WHERE mac = %(mac)s AND unique_id = %(uid)s AND disk_id = %(diskid)s AND userid != %(userid)s AND activated = 1 LIMIT 1", {
|
|
"mac": hashes[2],
|
|
"uid": hashes[3],
|
|
"diskid": hashes[4],
|
|
"userid": userID
|
|
})
|
|
|
|
if match:
|
|
# This is a multiaccount, restrict other account and ban this account
|
|
|
|
# Get original userID and username (lowest ID)
|
|
originalUserID = match[0]["userid"]
|
|
originalUsername = getUsername(originalUserID)
|
|
|
|
# Ban this user and append notes
|
|
ban(userID) # this removes the USER_PENDING_VERIFICATION flag too
|
|
appendNotes(userID, "{}'s multiaccount ({}), found HWID match while verifying account ({})".format(originalUsername, originalUserID, hashes[2:5]))
|
|
appendNotes(originalUserID, "Has created multiaccount {} ({})".format(username, userID))
|
|
|
|
# Restrict the original
|
|
restrict(originalUserID)
|
|
|
|
# Discord message
|
|
log.warning("User **{originalUsername}** ({originalUserID}) has been restricted because he has created multiaccount **{username}** ({userID}). The multiaccount has been banned.".format(
|
|
originalUsername=originalUsername,
|
|
originalUserID=originalUserID,
|
|
username=username,
|
|
userID=userID
|
|
), "cm")
|
|
|
|
# Disallow login
|
|
return False
|
|
else:
|
|
# No matches found, set USER_PUBLIC and USER_NORMAL flags and reset USER_PENDING_VERIFICATION flag
|
|
resetPendingFlag(userID)
|
|
#log.info("User **{}** ({}) has verified his account with hash set _{}_".format(username, userID, hashes[2:5]), "cm")
|
|
|
|
# Allow login
|
|
return True
|
|
|
|
def hasVerifiedHardware(userID):
|
|
"""
|
|
Checks if `userID` has activated his account through HWID
|
|
|
|
:param userID: user id
|
|
:return: True if hwid activation data is in db, otherwise False
|
|
"""
|
|
data = glob.db.fetch("SELECT id FROM hw_user WHERE userid = %s AND activated = 1 LIMIT 1", [userID])
|
|
if data is not None:
|
|
return True
|
|
return False
|
|
|
|
def getDonorExpire(userID):
|
|
"""
|
|
Return `userID`'s donor expiration UNIX timestamp
|
|
|
|
:param userID: user id
|
|
:return: donor expiration UNIX timestamp
|
|
"""
|
|
data = glob.db.fetch("SELECT donor_expire FROM users WHERE id = %s LIMIT 1", [userID])
|
|
if data is not None:
|
|
return data["donor_expire"]
|
|
return 0
|
|
|
|
|
|
class invalidUsernameError(Exception):
|
|
pass
|
|
|
|
class usernameAlreadyInUseError(Exception):
|
|
pass
|
|
|
|
def safeUsername(username):
|
|
"""
|
|
Return `username`'s safe username
|
|
(all lowercase and underscores instead of spaces)
|
|
|
|
:param username: unsafe username
|
|
:return: safe username
|
|
"""
|
|
return username.lower().strip().replace(" ", "_")
|
|
|
|
def changeUsername(userID=0, oldUsername="", newUsername=""):
|
|
"""
|
|
Change `userID`'s username to `newUsername` in database
|
|
|
|
:param userID: user id. Required only if `oldUsername` is not passed.
|
|
:param oldUsername: username. Required only if `userID` is not passed.
|
|
:param newUsername: new username. Can't contain spaces and underscores at the same time.
|
|
:raise: invalidUsernameError(), usernameAlreadyInUseError()
|
|
:return:
|
|
"""
|
|
# Make sure new username doesn't have mixed spaces and underscores
|
|
if " " in newUsername and "_" in newUsername:
|
|
raise invalidUsernameError()
|
|
|
|
# Get safe username
|
|
newUsernameSafe = safeUsername(newUsername)
|
|
|
|
# Make sure this username is not already in use
|
|
if getIDSafe(newUsernameSafe) is not None:
|
|
raise usernameAlreadyInUseError()
|
|
|
|
# Get userID or oldUsername
|
|
if userID == 0:
|
|
userID = getID(oldUsername)
|
|
else:
|
|
oldUsername = getUsername(userID)
|
|
|
|
# Change username
|
|
glob.db.execute("UPDATE users SET username = %s, username_safe = %s WHERE id = %s LIMIT 1", [newUsername, newUsernameSafe, userID])
|
|
glob.db.execute("UPDATE users_stats SET username = %s WHERE id = %s LIMIT 1", [newUsername, userID])
|
|
|
|
# Empty redis username cache
|
|
# TODO: Le pipe woo woo
|
|
glob.redis.delete("ripple:userid_cache:{}".format(safeUsername(oldUsername)))
|
|
glob.redis.delete("ripple:change_username_pending:{}".format(userID))
|
|
|
|
def removeFromLeaderboard(userID):
|
|
"""
|
|
Removes userID from global and country leaderboards.
|
|
|
|
:param userID:
|
|
:return:
|
|
"""
|
|
# Remove the user from global and country leaderboards, for every mode
|
|
country = getCountry(userID).lower()
|
|
for mode in ["std", "taiko", "ctb", "mania"]:
|
|
glob.redis.zrem("ripple:leaderboard:{}".format(mode), str(userID))
|
|
if country is not None and len(country) > 0 and country != "xx":
|
|
glob.redis.zrem("ripple:leaderboard:{}:{}".format(mode, country), str(userID))
|
|
|
|
def deprecateTelegram2Fa(userID):
|
|
"""
|
|
Checks whether the user has enabled telegram 2fa on his account.
|
|
If so, disables 2fa and returns True.
|
|
If not, return False.
|
|
|
|
:param userID: id of the user
|
|
:return: True if 2fa has been disabled from the account otherwise False
|
|
"""
|
|
try:
|
|
telegram2Fa = glob.db.fetch("SELECT id FROM 2fa_telegram WHERE userid = %s LIMIT 1", (userID,))
|
|
except ProgrammingError:
|
|
# The table doesnt exist
|
|
return False
|
|
|
|
if telegram2Fa is not None:
|
|
glob.db.execute("DELETE FROM 2fa_telegram WHERE userid = %s LIMIT 1", (userID,))
|
|
return True
|
|
return False
|
|
|
|
def unlockAchievement(userID, achievementID):
|
|
glob.db.execute("INSERT INTO users_achievements (user_id, achievement_id, `time`) VALUES"
|
|
"(%s, %s, %s)", [userID, achievementID, int(time.time())])
|
|
|
|
def getAchievementsVersion(userID):
|
|
result = glob.db.fetch("SELECT achievements_version FROM users WHERE id = %s LIMIT 1", [userID])
|
|
if result is None:
|
|
return None
|
|
return result["achievements_version"]
|
|
|
|
def updateAchievementsVersion(userID):
|
|
glob.db.execute("UPDATE users SET achievements_version = %s WHERE id = %s LIMIT 1", [
|
|
glob.ACHIEVEMENTS_VERSION, userID
|
|
])
|