1269 lines
50 KiB
Python
1269 lines
50 KiB
Python
import random
|
|
from sqlalchemy import Table, Column, UniqueConstraint # type: ignore
|
|
from sqlalchemy.types import String, Integer, JSON # type: ignore
|
|
from sqlalchemy.dialects.mysql import BIGINT as BigInteger # type: ignore
|
|
from sqlalchemy.exc import IntegrityError # type: ignore
|
|
from typing import Optional, Dict, List, Tuple, Any
|
|
from typing_extensions import Final
|
|
from passlib.hash import pbkdf2_sha512 # type: ignore
|
|
|
|
from bemani.common import ValidatedDict, Profile, GameConstants, Time
|
|
from bemani.data.mysql.base import BaseData, metadata
|
|
from bemani.data.remoteuser import RemoteUser
|
|
from bemani.data.types import User, Achievement, Link, UserID, ArcadeID
|
|
|
|
"""
|
|
Table representing a user. Each user has a unique ID and a pin which
|
|
is used with all cards associated with the user's account. Username
|
|
and password are optional as a user does not need to create a web login
|
|
to use the network. However, an active user account is required
|
|
before creating a web login.
|
|
"""
|
|
user = Table(
|
|
'user',
|
|
metadata,
|
|
Column('id', Integer, nullable=False, primary_key=True),
|
|
Column('pin', String(4), nullable=False),
|
|
Column('username', String(255), unique=True),
|
|
Column('password', String(255)),
|
|
Column('email', String(255)),
|
|
Column('admin', Integer),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
"""
|
|
Table representing a card associated with a user. Users may have zero
|
|
or more cards associated with them. When a new card is used in a game
|
|
a new user will be created to associate with a card, but it can later
|
|
be unlinked.
|
|
"""
|
|
card = Table(
|
|
'card',
|
|
metadata,
|
|
Column('id', String(16), nullable=False, unique=True),
|
|
Column('userid', BigInteger(unsigned=True), nullable=False, index=True),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
"""
|
|
Table representing an extid for a user across a game series. Each game
|
|
series on the network gets its own extid (8 digit number) for each user.
|
|
"""
|
|
extid = Table(
|
|
'extid',
|
|
metadata,
|
|
Column('game', String(32), nullable=False),
|
|
Column('extid', Integer, nullable=False, unique=True),
|
|
Column('userid', BigInteger(unsigned=True), nullable=False),
|
|
UniqueConstraint('game', 'userid', name='game_userid'),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
"""
|
|
Table representing a refid for a user. Each unique game on the network will
|
|
need a refid for each user/game/version they have a profile for. If a user
|
|
does not have a profile for a particular game, a new and unique refid
|
|
will be generated for the user.
|
|
|
|
Note that a user might have an extid/refid for a game without a profile,
|
|
but a user cannot have a profile without an extid/refid.
|
|
"""
|
|
refid = Table(
|
|
'refid',
|
|
metadata,
|
|
Column('game', String(32), nullable=False),
|
|
Column('version', Integer, nullable=False),
|
|
Column('refid', String(16), nullable=False, unique=True),
|
|
Column('userid', BigInteger(unsigned=True), nullable=False),
|
|
UniqueConstraint('game', 'version', 'userid', name='game_version_userid'),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
"""
|
|
Table for storing JSON profile blobs, indexed by refid.
|
|
"""
|
|
profile = Table(
|
|
'profile',
|
|
metadata,
|
|
Column('refid', String(16), nullable=False, unique=True),
|
|
Column('data', JSON, nullable=False),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
"""
|
|
Table for storing game achievements. An achievement is just a blob of data
|
|
with a unique ID and type. Games are free to store a JSON blob for each
|
|
achievement. Examples would be tran medals, event unlocks, items earned,
|
|
etc.
|
|
"""
|
|
achievement = Table(
|
|
'achievement',
|
|
metadata,
|
|
Column('refid', String(16), nullable=False),
|
|
Column('id', Integer, nullable=False),
|
|
Column('type', String(64), nullable=False),
|
|
Column('data', JSON, nullable=False),
|
|
UniqueConstraint('refid', 'id', 'type', name='refid_id_type'),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
"""
|
|
Table for storing time-based achievements. A time-based achievement is
|
|
almost identical to a regular achievement, but you can earn multiple of
|
|
the same type of achievement at different times, and it matters when
|
|
you earn it. Games are free to store a JSON blob for each achievement and
|
|
the blob does not need to be equal across different instances of the same
|
|
achievement for the same user. Examples would be calorie earnings for DDR.
|
|
"""
|
|
time_based_achievement = Table(
|
|
'time_based_achievement',
|
|
metadata,
|
|
Column('refid', String(16), nullable=False),
|
|
Column('id', Integer, nullable=False),
|
|
Column('type', String(64), nullable=False),
|
|
Column('timestamp', Integer, nullable=False, index=True),
|
|
Column('data', JSON, nullable=False),
|
|
UniqueConstraint('refid', 'id', 'type', 'timestamp', name='refid_id_type_timestamp'),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
"""
|
|
Table for storing a user's PASELI balance, given an arcade. There is no global
|
|
balance on this network.
|
|
"""
|
|
balance = Table(
|
|
'balance',
|
|
metadata,
|
|
Column('userid', BigInteger(unsigned=True), nullable=False),
|
|
Column('arcadeid', Integer, nullable=False),
|
|
Column('balance', Integer, nullable=False),
|
|
UniqueConstraint('userid', 'arcadeid', name='userid_arcadeid'),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
"""
|
|
Table for storing links between two users in a game/version, whatever that
|
|
may be. Typically used for rivals.
|
|
etc.
|
|
"""
|
|
link = Table(
|
|
'link',
|
|
metadata,
|
|
Column('game', String(32), nullable=False),
|
|
Column('version', Integer, nullable=False),
|
|
Column('userid', BigInteger(unsigned=True), nullable=False),
|
|
Column('type', String(64), nullable=False),
|
|
Column('other_userid', BigInteger(unsigned=True), nullable=False),
|
|
Column('data', JSON, nullable=False),
|
|
UniqueConstraint('game', 'version', 'userid', 'type', 'other_userid', name='game_version_userid_type_other_uuserid'),
|
|
mysql_charset='utf8mb4',
|
|
)
|
|
|
|
|
|
class AccountCreationException(Exception):
|
|
pass
|
|
|
|
|
|
class UserData(BaseData):
|
|
|
|
REF_ID_LENGTH: Final[int] = 16
|
|
|
|
def from_cardid(self, cardid: str) -> Optional[UserID]:
|
|
"""
|
|
Given a 16 digit card ID, look up a user ID.
|
|
|
|
Note that this is the E004 number as stored on the card. Not the 16 digit
|
|
ASCII value on the back. Use CardCipher to convert.
|
|
|
|
Parameters:
|
|
cardid - 16-digit card ID to look for.
|
|
|
|
Returns:
|
|
User ID as an integer if found, or None if not.
|
|
"""
|
|
# First, look up the user account
|
|
sql = "SELECT userid FROM card WHERE id = :id"
|
|
cursor = self.execute(sql, {'id': cardid})
|
|
if cursor.rowcount != 1:
|
|
# Couldn't find a user with this card
|
|
return None
|
|
|
|
result = cursor.fetchone()
|
|
return UserID(result['userid'])
|
|
|
|
def from_username(self, username: str) -> Optional[UserID]:
|
|
"""
|
|
Given a username, look up a user ID.
|
|
|
|
Parameters:
|
|
username - A string representing the user's username.
|
|
|
|
Returns:
|
|
User ID as an integer if found, or None if not.
|
|
"""
|
|
sql = "SELECT id FROM user WHERE username = :username"
|
|
cursor = self.execute(sql, {'username': username})
|
|
if cursor.rowcount != 1:
|
|
# Couldn't find this username
|
|
return None
|
|
|
|
result = cursor.fetchone()
|
|
return UserID(result['id'])
|
|
|
|
def from_refid(self, game: GameConstants, version: int, refid: str) -> Optional[UserID]:
|
|
"""
|
|
Given a generated RefID, look up a user ID.
|
|
|
|
Note that there is a unique RefID and ExtID for each profile, and both can be used
|
|
to look up a user. When creating a new profile, we generate a unique RefID and ExtID.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
refid - RefID in question, most likely previously generated by this class.
|
|
|
|
Returns:
|
|
User ID as an integer if found, or None if not.
|
|
"""
|
|
# First, look up the user account
|
|
sql = "SELECT userid FROM refid WHERE game = :game AND version = :version AND refid = :refid"
|
|
cursor = self.execute(sql, {'game': game.value, 'version': version, 'refid': refid})
|
|
if cursor.rowcount != 1:
|
|
# Couldn't find a user with this refid
|
|
return None
|
|
|
|
result = cursor.fetchone()
|
|
return UserID(result['userid'])
|
|
|
|
def from_extid(self, game: GameConstants, version: int, extid: int) -> Optional[UserID]:
|
|
"""
|
|
Given a generated ExtID, look up a user ID.
|
|
|
|
Note that there is a unique RefID and ExtID for each profile, and both can be used
|
|
to look up a user. When creating a new profile, we generate a unique RefID and ExtID.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
extid - ExtID in question, most likely previously generated by this class.
|
|
|
|
Returns:
|
|
User ID as an integer if found, or None if not.
|
|
"""
|
|
# First, look up the user account
|
|
sql = "SELECT userid FROM extid WHERE game = :game AND extid = :extid"
|
|
cursor = self.execute(sql, {'game': game.value, 'extid': extid})
|
|
if cursor.rowcount != 1:
|
|
# Couldn't find a user with this refid
|
|
return None
|
|
|
|
result = cursor.fetchone()
|
|
return UserID(result['userid'])
|
|
|
|
def from_session(self, session: str) -> Optional[UserID]:
|
|
"""
|
|
Given a previously-opened session, look up a user ID.
|
|
|
|
Parameters:
|
|
session - String identifying a session that was opened by create_session.
|
|
|
|
Returns:
|
|
User ID as an integer if found, or None if the session is expired or doesn't exist.
|
|
"""
|
|
userid = self._from_session(session, 'userid')
|
|
if userid is None:
|
|
return None
|
|
return UserID(userid)
|
|
|
|
def get_user(self, userid: UserID) -> Optional[User]:
|
|
"""
|
|
Given a userid, look up details about the account.
|
|
|
|
Parameters:
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
A User object if found, or None otherwise.
|
|
"""
|
|
sql = "SELECT username, email, admin FROM user WHERE id = :userid"
|
|
cursor = self.execute(sql, {'userid': userid})
|
|
if cursor.rowcount != 1:
|
|
# User doesn't exist, but we have a reference?
|
|
return None
|
|
|
|
result = cursor.fetchone()
|
|
return User(userid, result['username'], result['email'], result['admin'] == 1)
|
|
|
|
def get_all_users(self) -> List[User]:
|
|
"""
|
|
Look up all users in the system.
|
|
|
|
Returns:
|
|
A list of User objects representing all users.
|
|
"""
|
|
sql = "SELECT id, username, email, admin FROM user"
|
|
cursor = self.execute(sql)
|
|
return [
|
|
User(UserID(result['id']), result['username'], result['email'], result['admin'] == 1)
|
|
for result in cursor.fetchall()
|
|
]
|
|
|
|
def get_all_usernames(self) -> List[str]:
|
|
"""
|
|
Look up all valid usernames in the system.
|
|
|
|
Parameters:
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
A list of strings representing usernames.
|
|
"""
|
|
sql = "SELECT username FROM user WHERE username is not null"
|
|
cursor = self.execute(sql)
|
|
return [res['username'] for res in cursor.fetchall()]
|
|
|
|
def get_all_cards(self) -> List[Tuple[str, UserID]]:
|
|
"""
|
|
Look up all cards associated with any account.
|
|
|
|
Returns:
|
|
A list of Tuples representing representing card ID, user ID pairs.
|
|
"""
|
|
sql = "SELECT id, userid FROM card"
|
|
cursor = self.execute(sql)
|
|
return [(str(res['id']).upper(), UserID(res['userid'])) for res in cursor.fetchall()]
|
|
|
|
def get_cards(self, userid: UserID) -> List[str]:
|
|
"""
|
|
Given a userid, look up all cards associated with the account.
|
|
|
|
Parameters:
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
A list of strings representing card IDs.
|
|
"""
|
|
sql = "SELECT id FROM card WHERE userid = :userid"
|
|
cursor = self.execute(sql, {'userid': userid})
|
|
return [str(res['id']).upper() for res in cursor.fetchall()]
|
|
|
|
def add_card(self, userid: UserID, cardid: str) -> None:
|
|
"""
|
|
Given a user ID and a card ID, link that card with that user.
|
|
|
|
Note that this is the E004 number as stored on the card. Not the 16 digit
|
|
ASCII value on the back. Use CardCipher to convert.
|
|
|
|
Parameters:
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
cardid - 16-digit card ID to add.
|
|
"""
|
|
sql = "INSERT INTO card (userid, id) VALUES (:userid, :cardid)"
|
|
self.execute(sql, {'userid': userid, 'cardid': cardid})
|
|
|
|
oldid = RemoteUser.card_to_userid(cardid)
|
|
if RemoteUser.is_remote(oldid):
|
|
# Kill any refid/extid that related to this card, since its now associated
|
|
# with another existing account.
|
|
sql = "DELETE FROM extid WHERE userid = :oldid"
|
|
self.execute(sql, {'oldid': oldid})
|
|
sql = "DELETE FROM refid WHERE userid = :oldid"
|
|
self.execute(sql, {'oldid': oldid})
|
|
|
|
# Point at the new account for any rivals against this card. Note that this
|
|
# might result in a duplicate rival, but its a very small edge case.
|
|
sql = "UPDATE link SET other_userid = :newid WHERE other_userid = :oldid"
|
|
self.execute(sql, {'newid': userid, 'oldid': oldid})
|
|
|
|
def destroy_card(self, userid: UserID, cardid: str) -> None:
|
|
"""
|
|
Given a user ID and a card ID, remove the card ID link from that user.
|
|
|
|
Note that this is the E004 number as stored on the card. Not the 16 digit
|
|
ASCII value on the back. Use CardCipher to convert.
|
|
|
|
Parameters:
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
cardid - 16-digit card ID to remove.
|
|
"""
|
|
sql = "DELETE FROM card WHERE id = :cardid AND userid = :userid LIMIT 1"
|
|
self.execute(sql, {'cardid': cardid, 'userid': userid})
|
|
|
|
def put_user(self, user: User) -> None:
|
|
"""
|
|
Given a user object, update the DB to save new user info.
|
|
|
|
Parameters:
|
|
user - A user, which has optional values set.
|
|
"""
|
|
sql = "UPDATE user SET username = :username, email = :email, admin = :admin WHERE id = :userid"
|
|
self.execute(
|
|
sql,
|
|
{
|
|
'username': user.username,
|
|
'email': user.email,
|
|
'admin': 1 if user.admin else 0,
|
|
'userid': user.id,
|
|
},
|
|
)
|
|
|
|
def validate_pin(self, userid: UserID, pin: str) -> bool:
|
|
"""
|
|
Given a userid and PIN, validate the PIN.
|
|
|
|
Parameters:
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
pin - 4 digit string returned by the game for PIN entry.
|
|
|
|
Returns:
|
|
True if PIN is valid, False otherwise.
|
|
"""
|
|
sql = "SELECT pin FROM user WHERE id = :userid"
|
|
cursor = self.execute(sql, {'userid': userid})
|
|
if cursor.rowcount != 1:
|
|
# User doesn't exist, but we have a reference?
|
|
return False
|
|
|
|
result = cursor.fetchone()
|
|
return pin == result['pin']
|
|
|
|
def update_pin(self, userid: UserID, pin: str) -> None:
|
|
"""
|
|
Given a userid and a new PIN, update the PIN for that user.
|
|
|
|
Parameters:
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
pin - 4 digit string returned by the game for PIN entry.
|
|
"""
|
|
sql = "UPDATE user SET pin = :pin WHERE id = :userid"
|
|
self.execute(sql, {'pin': pin, 'userid': userid})
|
|
|
|
def validate_password(self, userid: UserID, password: str) -> bool:
|
|
"""
|
|
Given a password, validate that the password matches the stored hash
|
|
|
|
Parameters:
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
password - String, plaintext password that will be hashed
|
|
|
|
Returns:
|
|
True if password is valid, False otherwise.
|
|
"""
|
|
sql = "SELECT password FROM user WHERE id = :userid"
|
|
cursor = self.execute(sql, {'userid': userid})
|
|
if cursor.rowcount != 1:
|
|
# User doesn't exist, but we have a reference?
|
|
return False
|
|
|
|
result = cursor.fetchone()
|
|
passhash = result['password']
|
|
|
|
try:
|
|
# Verifying the password
|
|
return pbkdf2_sha512.verify(password, passhash)
|
|
except (ValueError, TypeError):
|
|
return False
|
|
|
|
def update_password(self, userid: UserID, password: str) -> None:
|
|
"""
|
|
Given a userid and a new password, update the password for that user.
|
|
|
|
Parameters:
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
password - String, plaintext password that will be hashed
|
|
"""
|
|
passhash = pbkdf2_sha512.hash(password)
|
|
sql = "UPDATE user SET password = :hash WHERE id = :userid"
|
|
self.execute(sql, {'hash': passhash, 'userid': userid})
|
|
|
|
def get_profile(self, game: GameConstants, version: int, userid: UserID) -> Optional[Profile]:
|
|
"""
|
|
Given a game/version/userid, look up the associated profile.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
A dictionary previously stored by a game class if found, or None otherwise.
|
|
"""
|
|
sql = (
|
|
"SELECT refid.refid AS refid, extid.extid AS extid, profile.data AS data " +
|
|
"FROM refid, extid, profile " +
|
|
"WHERE refid.userid = :userid AND refid.game = :game AND refid.version = :version AND "
|
|
"extid.userid = refid.userid AND extid.game = refid.game AND profile.refid = refid.refid"
|
|
)
|
|
cursor = self.execute(sql, {'userid': userid, 'game': game.value, 'version': version})
|
|
if cursor.rowcount != 1:
|
|
# Profile doesn't exist
|
|
return None
|
|
|
|
result = cursor.fetchone()
|
|
return Profile(
|
|
game,
|
|
version,
|
|
result['refid'],
|
|
result['extid'],
|
|
self.deserialize(result['data']),
|
|
)
|
|
|
|
def get_any_profile(self, game: GameConstants, version: int, userid: UserID) -> Optional[Profile]:
|
|
"""
|
|
Given a game/version/userid, look up the associated profile. If the profile for that version
|
|
doesn't exist, try another profile, failing only if there is no profile for any version of
|
|
this game.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
A dictionary previously stored by a game class if found, or None otherwise.
|
|
"""
|
|
played = self.get_games_played(userid, game=game)
|
|
versions = {p[1] for p in played}
|
|
|
|
if version in versions:
|
|
return self.get_profile(game, version, userid)
|
|
elif len(versions) > 0:
|
|
return self.get_profile(game, max(versions), userid)
|
|
else:
|
|
return None
|
|
|
|
def get_any_profiles(self, game: GameConstants, version: int, userids: List[UserID]) -> List[Tuple[UserID, Optional[Profile]]]:
|
|
"""
|
|
Does the exact same thing as get_any_profile but across a list of users instead of one.
|
|
Provided purely as a convenience function.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userids - List of Integer user IDs, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
A List of tuples containing a userid and a dictionary previously stored by a game class if found,
|
|
or None otherwise.
|
|
"""
|
|
if not userids:
|
|
return []
|
|
sql = "SELECT version, userid FROM refid WHERE game = :game AND userid IN :userids AND refid IN (SELECT refid FROM profile)"
|
|
cursor = self.execute(sql, {'game': game.value, 'userids': userids})
|
|
profilever: Dict[UserID, int] = {}
|
|
|
|
for result in cursor.fetchall():
|
|
tuid = UserID(result['userid'])
|
|
tver = result['version']
|
|
|
|
if tuid not in profilever:
|
|
# Just assign it the first profile we find
|
|
profilever[tuid] = tver
|
|
else:
|
|
# If the profile for this version exists, prioritize it
|
|
if tver == version:
|
|
profilever[tuid] = tver
|
|
|
|
# Only update the profile version with the newest game profile if the game
|
|
# profile for this version doesn't exist.
|
|
elif profilever[tuid] != version:
|
|
profilever[tuid] = max(profilever[tuid], tver)
|
|
|
|
result = []
|
|
for uid in userids:
|
|
if uid not in profilever:
|
|
result.append((uid, None))
|
|
else:
|
|
result.append((uid, self.get_profile(game, profilever[uid], uid)))
|
|
return result
|
|
|
|
def get_games_played(self, userid: UserID, game: Optional[GameConstants] = None) -> List[Tuple[GameConstants, int]]:
|
|
"""
|
|
Given a user ID, look up all game/version combos this user has played.
|
|
|
|
Parameters:
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
game - An optional game series to constrain search to.
|
|
|
|
Returns:
|
|
A List of Tuples of game, version for each game/version the user has played.
|
|
"""
|
|
sql = "SELECT game, version FROM refid WHERE userid = :userid AND refid IN (SELECT refid FROM profile)"
|
|
vals: Dict[str, Any] = {'userid': userid}
|
|
|
|
if game is not None:
|
|
sql += " AND game = :game"
|
|
vals['game'] = game.value
|
|
|
|
cursor = self.execute(sql, vals)
|
|
profiles = []
|
|
for result in cursor.fetchall():
|
|
profiles.append((GameConstants(result['game']), result['version']))
|
|
return profiles
|
|
|
|
def get_all_profiles(self, game: GameConstants, version: int) -> List[Tuple[UserID, Profile]]:
|
|
"""
|
|
Given a game/version, look up all user profiles for that game.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game we want all user profiles for.
|
|
version - Integer version of the game we want all user profiles for.
|
|
|
|
Returns:
|
|
A list of (UserID, dictionaries) previously stored by a game class for each profile.
|
|
"""
|
|
sql = (
|
|
"SELECT refid.userid AS userid, refid.refid AS refid, extid.extid AS extid, profile.data AS data "
|
|
"FROM refid, profile, extid "
|
|
"WHERE refid.game = :game AND refid.version = :version "
|
|
"AND refid.refid = profile.refid AND extid.game = refid.game AND extid.userid = refid.userid"
|
|
)
|
|
cursor = self.execute(sql, {'game': game.value, 'version': version})
|
|
|
|
profiles = []
|
|
for result in cursor.fetchall():
|
|
profiles.append(
|
|
(
|
|
UserID(result['userid']),
|
|
Profile(
|
|
game,
|
|
version,
|
|
result['refid'],
|
|
result['extid'],
|
|
self.deserialize(result['data']),
|
|
)
|
|
)
|
|
)
|
|
|
|
return profiles
|
|
|
|
def get_all_players(self, game: GameConstants, version: int) -> List[UserID]:
|
|
"""
|
|
Given a game/version, look up all user IDs that played this game/version.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game we want all user profiles for.
|
|
version - Integer version of the game we want all user profiles for.
|
|
|
|
Returns:
|
|
A list of UserIDs for users that played this version of this game.
|
|
"""
|
|
sql = (
|
|
"SELECT refid.userid AS userid FROM refid "
|
|
"WHERE refid.game = :game AND refid.version = :version"
|
|
)
|
|
cursor = self.execute(sql, {'game': game.value, 'version': version})
|
|
|
|
return [UserID(result['userid']) for result in cursor.fetchall()]
|
|
|
|
def get_all_achievements(self, game: GameConstants, version: int, achievementid: Optional[int] = None, achievementtype: Optional[str] = None) -> List[Tuple[UserID, Achievement]]:
|
|
"""
|
|
Given a game/version, find all achievements for all players.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
|
|
Returns:
|
|
A list of (UserID, Achievement) objects.
|
|
"""
|
|
sql = (
|
|
"SELECT achievement.id AS id, achievement.type AS type, achievement.data AS data, "
|
|
"refid.userid AS userid FROM achievement, refid WHERE refid.game = :game AND "
|
|
"refid.version = :version AND refid.refid = achievement.refid"
|
|
)
|
|
params: Dict[str, Any] = {'game': game.value, 'version': version}
|
|
if achievementtype is not None:
|
|
sql += " AND achievement.type = :type"
|
|
params['type'] = achievementtype
|
|
if achievementid is not None:
|
|
sql += " AND achievement.id = :id"
|
|
params['id'] = achievementid
|
|
cursor = self.execute(sql, params)
|
|
|
|
achievements = []
|
|
for result in cursor.fetchall():
|
|
achievements.append(
|
|
(
|
|
UserID(result['userid']),
|
|
Achievement(
|
|
result['id'],
|
|
result['type'],
|
|
None,
|
|
self.deserialize(result['data']),
|
|
),
|
|
)
|
|
)
|
|
|
|
return achievements
|
|
|
|
def put_profile(self, game: GameConstants, version: int, userid: UserID, profile: Profile) -> None:
|
|
"""
|
|
Given a game/version/userid, save an associated profile.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
profile - A dictionary that a game class will want to retrieve later.
|
|
"""
|
|
refid = self.get_refid(game, version, userid)
|
|
|
|
# Add profile json to game profile
|
|
sql = (
|
|
"INSERT INTO profile (refid, data) " +
|
|
"VALUES (:refid, :json) " +
|
|
"ON DUPLICATE KEY UPDATE data=VALUES(data)"
|
|
)
|
|
self.execute(sql, {'refid': refid, 'json': self.serialize(profile)})
|
|
|
|
# Update profile details just in case this was a new profile that was just saved.
|
|
profile.game = game
|
|
profile.version = version
|
|
profile.refid = refid
|
|
if profile.extid == 0:
|
|
profile.extid = self.get_extid(game, version, userid)
|
|
|
|
def delete_profile(self, game: GameConstants, version: int, userid: UserID) -> None:
|
|
"""
|
|
Given a game/version/userid, delete any associated profile.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
"""
|
|
refid = self.get_refid(game, version, userid)
|
|
|
|
# Delete profile JSON to unlink the profile for this game/version.
|
|
sql = "DELETE FROM profile WHERE refid = :refid LIMIT 1"
|
|
self.execute(sql, {'refid': refid})
|
|
|
|
def get_achievement(self, game: GameConstants, version: int, userid: UserID, achievementid: int, achievementtype: str) -> Optional[ValidatedDict]:
|
|
"""
|
|
Given a game/version/userid and achievement id/type, find that achievement.
|
|
|
|
Note that there can be more than one achievement with the same ID and game/version/userid
|
|
as long as each one is a different type. Essentially, achievementtype namespaces achievements.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
achievementid - Integer ID, as provided by a game.
|
|
achievementtype - The type of achievement.
|
|
|
|
Returns:
|
|
A dictionary as stored by a game class previously, or None if not found.
|
|
"""
|
|
refid = self.get_refid(game, version, userid)
|
|
sql = (
|
|
"SELECT data FROM achievement WHERE refid = :refid AND id = :id AND type = :type"
|
|
)
|
|
cursor = self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype})
|
|
if cursor.rowcount != 1:
|
|
# score doesn't exist
|
|
return None
|
|
|
|
result = cursor.fetchone()
|
|
return ValidatedDict(self.deserialize(result['data']))
|
|
|
|
def get_achievements(self, game: GameConstants, version: int, userid: UserID) -> List[Achievement]:
|
|
"""
|
|
Given a game/version/userid, find all achievements
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
A list of Achievement objects.
|
|
"""
|
|
refid = self.get_refid(game, version, userid)
|
|
sql = "SELECT id, type, data FROM achievement WHERE refid = :refid"
|
|
cursor = self.execute(sql, {'refid': refid})
|
|
|
|
achievements = []
|
|
for result in cursor.fetchall():
|
|
achievements.append(
|
|
Achievement(
|
|
result['id'],
|
|
result['type'],
|
|
None,
|
|
self.deserialize(result['data']),
|
|
)
|
|
)
|
|
|
|
return achievements
|
|
|
|
def put_achievement(self, game: GameConstants, version: int, userid: UserID, achievementid: int, achievementtype: str, data: Dict[str, Any]) -> None:
|
|
"""
|
|
Given a game/version/userid and achievement id/type, save an achievement.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
achievementid - Integer ID, as provided by a game.
|
|
achievementtype - The type of achievement.
|
|
data - A dictionary of data that the game wishes to retrieve later.
|
|
"""
|
|
refid = self.get_refid(game, version, userid)
|
|
|
|
# Add achievement JSON to achievements
|
|
sql = (
|
|
"INSERT INTO achievement (refid, id, type, data) " +
|
|
"VALUES (:refid, :id, :type, :data) " +
|
|
"ON DUPLICATE KEY UPDATE data=VALUES(data)"
|
|
)
|
|
self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype, 'data': self.serialize(data)})
|
|
|
|
def destroy_achievement(self, game: GameConstants, version: int, userid: UserID, achievementid: int, achievementtype: str) -> None:
|
|
"""
|
|
Given a game/version/userid and achievement id/type, delete an achievement.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
achievementid - Integer ID, as provided by a game.
|
|
achievementtype - The type of achievement.
|
|
"""
|
|
refid = self.get_refid(game, version, userid)
|
|
|
|
# Nuke the achievement from the user
|
|
sql = (
|
|
"DELETE FROM achievement WHERE refid = :refid AND id = :id AND type = :type"
|
|
)
|
|
self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype})
|
|
|
|
def get_time_based_achievements(
|
|
self,
|
|
game: GameConstants,
|
|
version: int,
|
|
userid: UserID,
|
|
achievementtype: Optional[str]=None,
|
|
since: Optional[int]=None,
|
|
until: Optional[int]=None,
|
|
) -> List[Achievement]:
|
|
"""
|
|
Given a game/version/userid, find all time-based achievements
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
achievementtype - Optional string specifying to constrain to a type of achievement.
|
|
since - Return achievements since this time (inclusive).
|
|
until - Return achievements until this time (exclusive).
|
|
|
|
Returns:
|
|
A list of Achievement objects.
|
|
"""
|
|
refid = self.get_refid(game, version, userid)
|
|
sql = "SELECT id, type, timestamp, data FROM time_based_achievement WHERE refid = :refid"
|
|
if achievementtype is not None:
|
|
sql += " AND type = :type"
|
|
if since is not None:
|
|
sql += " AND timestamp >= :since"
|
|
if until is not None:
|
|
sql += " AND timestamp < :until"
|
|
cursor = self.execute(sql, {'refid': refid, 'type': achievementtype, 'since': since, 'until': until})
|
|
|
|
achievements = []
|
|
for result in cursor.fetchall():
|
|
achievements.append(
|
|
Achievement(
|
|
result['id'],
|
|
result['type'],
|
|
result['timestamp'],
|
|
self.deserialize(result['data']),
|
|
)
|
|
)
|
|
|
|
return achievements
|
|
|
|
def put_time_based_achievement(
|
|
self,
|
|
game: GameConstants,
|
|
version: int,
|
|
userid: UserID,
|
|
achievementid: int,
|
|
achievementtype: str,
|
|
data: Dict[str, Any],
|
|
) -> None:
|
|
"""
|
|
Given a game/version/userid and achievement id/type, save a time-based achievement. Assumes that
|
|
time-based achievements are immutable once saved.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
achievementid - Integer ID, as provided by a game.
|
|
achievementtype - The type of achievement.
|
|
data - A dictionary of data that the game wishes to retrieve later.
|
|
"""
|
|
refid = self.get_refid(game, version, userid)
|
|
|
|
# Add achievement JSON to achievements
|
|
sql = (
|
|
"INSERT INTO time_based_achievement (refid, id, type, timestamp, data) " +
|
|
"VALUES (:refid, :id, :type, :ts, :data)"
|
|
)
|
|
self.execute(sql, {'refid': refid, 'id': achievementid, 'type': achievementtype, 'ts': Time.now(), 'data': self.serialize(data)})
|
|
|
|
def get_all_time_based_achievements(self, game: GameConstants, version: int) -> List[Tuple[UserID, Achievement]]:
|
|
"""
|
|
Given a game/version, find all time-based achievements for all players.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
|
|
Returns:
|
|
A list of (UserID, Achievement) objects.
|
|
"""
|
|
sql = (
|
|
"SELECT time_based_achievement.id AS id, time_based_achievement.type AS type, "
|
|
"time_based_achievement.data AS data, time_based_achievement.timestamp AS timestamp, "
|
|
"refid.userid AS userid FROM time_based_achievement, refid WHERE refid.game = :game AND "
|
|
"refid.version = :version AND refid.refid = time_based_achievement.refid"
|
|
)
|
|
cursor = self.execute(sql, {'game': game.value, 'version': version})
|
|
|
|
achievements = []
|
|
for result in cursor.fetchall():
|
|
achievements.append(
|
|
(
|
|
UserID(result['userid']),
|
|
Achievement(
|
|
result['id'],
|
|
result['type'],
|
|
result['timestamp'],
|
|
self.deserialize(result['data']),
|
|
),
|
|
)
|
|
)
|
|
|
|
return achievements
|
|
|
|
def get_link(self, game: GameConstants, version: int, userid: UserID, linktype: str, other_userid: UserID) -> Optional[ValidatedDict]:
|
|
"""
|
|
Given a game/version/userid and link type + other userid, find that link.
|
|
|
|
Note that there can be more than one link with the same user IDs and game/version
|
|
as long as each one is a different type.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
linktype - The type of link.
|
|
other_userid - Integer user ID of the account we're linked to.
|
|
|
|
Returns:
|
|
A dictionary as stored by a game class previously, or None if not found.
|
|
"""
|
|
sql = (
|
|
"SELECT data FROM link WHERE game = :game AND version = :version AND userid = :userid AND type = :type AND other_userid = :other_userid"
|
|
)
|
|
cursor = self.execute(sql, {'game': game.value, 'version': version, 'userid': userid, 'type': linktype, 'other_userid': other_userid})
|
|
if cursor.rowcount != 1:
|
|
# score doesn't exist
|
|
return None
|
|
|
|
result = cursor.fetchone()
|
|
return ValidatedDict(self.deserialize(result['data']))
|
|
|
|
def get_links(self, game: GameConstants, version: int, userid: UserID) -> List[Link]:
|
|
"""
|
|
Given a game/version/userid, find all links between this user and other users
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
A list of Link objects.
|
|
"""
|
|
sql = "SELECT type, other_userid, data FROM link WHERE game = :game AND version = :version AND userid = :userid"
|
|
cursor = self.execute(sql, {'game': game.value, 'version': version, 'userid': userid})
|
|
|
|
links = []
|
|
for result in cursor.fetchall():
|
|
links.append(
|
|
Link(
|
|
userid,
|
|
result['type'],
|
|
UserID(result['other_userid']),
|
|
self.deserialize(result['data']),
|
|
)
|
|
)
|
|
|
|
return links
|
|
|
|
def put_link(self, game: GameConstants, version: int, userid: UserID, linktype: str, other_userid: UserID, data: Dict[str, Any]) -> None:
|
|
"""
|
|
Given a game/version/userid and link id + other_userid, save an link.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
linktype - The type of link.
|
|
other_userid - Integer user ID of the account we're linked to.
|
|
data - A dictionary of data that the game wishes to retrieve later.
|
|
"""
|
|
# Add link JSON to link
|
|
sql = (
|
|
"INSERT INTO link (game, version, userid, type, other_userid, data) "
|
|
"VALUES (:game, :version, :userid, :type, :other_userid, :data) "
|
|
"ON DUPLICATE KEY UPDATE data=VALUES(data)"
|
|
)
|
|
self.execute(sql, {'game': game.value, 'version': version, 'userid': userid, 'type': linktype, 'other_userid': other_userid, 'data': self.serialize(data)})
|
|
|
|
def destroy_link(self, game: GameConstants, version: int, userid: UserID, linktype: str, other_userid: UserID) -> None:
|
|
"""
|
|
Given a game/version/userid and link id + other_userid, destroy the link.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
linktype - The type of link.
|
|
other_userid - Integer user ID of the account we're linked to.
|
|
"""
|
|
sql = (
|
|
"DELETE FROM link WHERE game = :game AND version = :version AND userid = :userid AND type = :type AND other_userid = :other_userid"
|
|
)
|
|
self.execute(sql, {'game': game.value, 'version': version, 'userid': userid, 'type': linktype, 'other_userid': other_userid})
|
|
|
|
def get_balance(self, userid: UserID, arcadeid: ArcadeID) -> int:
|
|
"""
|
|
Given a user and an arcade ID, look up the user's PASELI balance for that arcade.
|
|
|
|
Parameters:
|
|
userid - The user ID in question, as looked up by this class.
|
|
arcadeid - The arcade in question.
|
|
|
|
Returns:
|
|
The PASELI balance for this user at this arcade.
|
|
"""
|
|
sql = "SELECT balance FROM balance WHERE userid = :userid AND arcadeid = :arcadeid"
|
|
cursor = self.execute(sql, {'userid': userid, 'arcadeid': arcadeid})
|
|
if cursor.rowcount == 1:
|
|
result = cursor.fetchone()
|
|
return result['balance']
|
|
else:
|
|
return 0
|
|
|
|
def update_balance(self, userid: UserID, arcadeid: ArcadeID, delta: int) -> Optional[int]:
|
|
"""
|
|
Given a user and an arcade ID, update the PASELI balance for that arcade.
|
|
|
|
Parameters:
|
|
userid - The user ID in question, as looked up by this class.
|
|
arcadeid - The arcade in question.
|
|
delta - The value to add (or subtract, if delta is negative).
|
|
|
|
Returns:
|
|
The new PASELI balance if successful, or None if there wasn't enough to apply the delta.
|
|
"""
|
|
sql = (
|
|
"INSERT INTO balance (userid, arcadeid, balance) VALUES (:userid, :arcadeid, :delta) "
|
|
"ON DUPLICATE KEY UPDATE balance = balance + :delta"
|
|
)
|
|
self.execute(sql, {'delta': delta, 'userid': userid, 'arcadeid': arcadeid})
|
|
newbalance = self.get_balance(userid, arcadeid)
|
|
if newbalance < 0:
|
|
# Went under while grabbing, put the balance back and return nothing
|
|
sql = "UPDATE balance SET balance = balance - :delta WHERE userid = :userid AND arcadeid = :arcadeid"
|
|
self.execute(sql, {'delta': delta, 'userid': userid, 'arcadeid': arcadeid})
|
|
return None
|
|
return newbalance
|
|
|
|
def get_refid(self, game: GameConstants, version: int, userid: UserID) -> str:
|
|
"""
|
|
Given a game/version and user ID, look up the RefID for the profile.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
The RefID associated with the profile for this user. If there isn't one, creates one
|
|
and returns it, which can be used for creating/looking up a profile in the future.
|
|
"""
|
|
sql = "SELECT refid FROM refid WHERE userid = :userid AND game = :game AND version = :version"
|
|
cursor = self.execute(sql, {'userid': userid, 'game': game.value, 'version': version})
|
|
if cursor.rowcount == 1:
|
|
result = cursor.fetchone()
|
|
return result['refid']
|
|
else:
|
|
return self.create_refid(game, version, userid)
|
|
|
|
def get_extid(self, game: GameConstants, version: int, userid: UserID) -> int:
|
|
"""
|
|
Given a game/version and a user ID, look up the ExtID for the profile.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
The ExtID associated with the profile for this user. If there isn't one, creates
|
|
one in the same manner as get_refid() above.
|
|
"""
|
|
|
|
def fetch_extid() -> Optional[int]:
|
|
sql = "SELECT extid FROM extid WHERE userid = :userid AND game = :game"
|
|
cursor = self.execute(sql, {'userid': userid, 'game': game.value})
|
|
if cursor.rowcount == 1:
|
|
result = cursor.fetchone()
|
|
return result['extid']
|
|
else:
|
|
return None
|
|
|
|
extid = fetch_extid()
|
|
if extid is not None:
|
|
return extid
|
|
else:
|
|
self.create_refid(game, version, userid)
|
|
extid = fetch_extid()
|
|
if extid is not None:
|
|
return extid
|
|
else:
|
|
raise AccountCreationException()
|
|
|
|
def create_session(self, userid: UserID, expiration: int=(30 * 86400)) -> str:
|
|
"""
|
|
Given a user ID, create a session string.
|
|
|
|
Parameters:
|
|
userid - User ID we wish to start a session for.
|
|
expiration - Number of seconds before this session is invalid.
|
|
|
|
Returns:
|
|
A string that can be used as a session ID.
|
|
"""
|
|
return self._create_session(userid, 'userid', expiration)
|
|
|
|
def destroy_session(self, session: str) -> None:
|
|
"""
|
|
Destroy a previously-created session.
|
|
|
|
Parameters:
|
|
session - A session string as returned from create_session.
|
|
"""
|
|
self._destroy_session(session, 'userid')
|
|
|
|
def create_refid(self, game: GameConstants, version: int, userid: UserID) -> str:
|
|
"""
|
|
Given a game/version/userid, create a RefID and an ExtID if necessary.
|
|
|
|
Note that while this function returns the created RefID, an ExtID is also
|
|
created and stored in the DB. Both RefID and ExtID are guaranteed to be
|
|
unique, but the RefID is guaranteed unique for each profile while ExtID
|
|
is guaranteed unique for each game series/user.
|
|
|
|
Parameters:
|
|
game - Enum value identifier of the game looking up the user.
|
|
version - Integer version of the game looking up the user.
|
|
userid - Integer user ID, as looked up by one of the above functions.
|
|
|
|
Returns:
|
|
A string RefID value.
|
|
"""
|
|
# Create a new extid that is unique
|
|
while True:
|
|
extid = random.randint(0, 89999999) + 10000000
|
|
sql = "SELECT extid FROM extid WHERE extid = :extid"
|
|
cursor = self.execute(sql, {'extid': extid})
|
|
if cursor.rowcount == 0:
|
|
break
|
|
|
|
# Use that extid
|
|
sql = (
|
|
"INSERT INTO extid (game, extid, userid) " +
|
|
"VALUES (:game, :extid, :userid)"
|
|
)
|
|
try:
|
|
cursor = self.execute(sql, {'game': game.value, 'extid': extid, 'userid': userid})
|
|
except IntegrityError:
|
|
# User already has an ExtID for this game series
|
|
pass
|
|
|
|
# Create a new refid that is unique
|
|
while True:
|
|
refid = ''.join(random.choice('0123456789ABCDEF') for _ in range(UserData.REF_ID_LENGTH))
|
|
sql = "SELECT refid FROM refid WHERE refid = :refid"
|
|
cursor = self.execute(sql, {'refid': refid})
|
|
if cursor.rowcount == 0:
|
|
break
|
|
|
|
# Use that refid
|
|
sql = (
|
|
"INSERT INTO refid (game, version, refid, userid) " +
|
|
"VALUES (:game, :version, :refid, :userid)"
|
|
)
|
|
try:
|
|
cursor = self.execute(sql, {'game': game.value, 'version': version, 'refid': refid, 'userid': userid})
|
|
if cursor.rowcount != 1:
|
|
raise AccountCreationException()
|
|
return refid
|
|
except IntegrityError:
|
|
# We maybe lost the race? Look up the ID from another creation. Don't call get_refid
|
|
# because it calls us, so we don't want an infinite loop.
|
|
sql = "SELECT refid FROM refid WHERE userid = :userid AND game = :game AND version = :version"
|
|
cursor = self.execute(sql, {'userid': userid, 'game': game.value, 'version': version})
|
|
if cursor.rowcount == 1:
|
|
result = cursor.fetchone()
|
|
return result['refid']
|
|
# Shouldn't be possible, but here we are
|
|
raise AccountCreationException()
|
|
|
|
def create_account(self, cardid: str, pin: str) -> Optional[UserID]:
|
|
"""
|
|
Given a Card ID and a PIN, create a new account.
|
|
|
|
Parameters:
|
|
cardid - 16-digit card ID of the card we are creating an account for.
|
|
pin - Four digit PIN as entered by the user on a cabinet.
|
|
|
|
Returns:
|
|
A User ID if creation was successful, or None otherwise.
|
|
"""
|
|
# First, create a user account
|
|
sql = "INSERT INTO user (pin, admin) VALUES (:pin, 0)"
|
|
cursor = self.execute(sql, {'pin': pin})
|
|
if cursor.rowcount != 1:
|
|
return None
|
|
userid = cursor.lastrowid
|
|
|
|
# Now, insert the card, tying it to the account
|
|
sql = "INSERT INTO card (id, userid) VALUES (:cardid, :userid)"
|
|
cursor = self.execute(sql, {'cardid': cardid, 'userid': userid})
|
|
if cursor.rowcount != 1:
|
|
return None
|
|
|
|
# Now, if this user played on a remote network and their profile
|
|
# was ever fetched locally or they were ever rivaled against,
|
|
# convert those locally too so that players don't lose rivals
|
|
# on new account creation.
|
|
oldid = RemoteUser.card_to_userid(cardid)
|
|
if RemoteUser.is_remote(oldid):
|
|
sql = "UPDATE extid SET userid = :newid WHERE userid = :oldid"
|
|
self.execute(sql, {'newid': userid, 'oldid': oldid})
|
|
sql = "UPDATE refid SET userid = :newid WHERE userid = :oldid"
|
|
self.execute(sql, {'newid': userid, 'oldid': oldid})
|
|
sql = "UPDATE link SET other_userid = :newid WHERE other_userid = :oldid"
|
|
self.execute(sql, {'newid': userid, 'oldid': oldid})
|
|
|
|
# Finally, return the user ID
|
|
return userid
|