def read_expanded(cls, slug, key):
game = get_game_by_slug(slug)
if game is None:
response.status_int = 404
return {'ok': False, 'msg': 'No game with that slug'}
params = request.GET
method_type = params.get('type', 'top')
def get_size(default_size, max_size):
try:
size = int(params.get('size', default_size))
if size <= 0 or size > max_size:
raise BadRequest('size must be a positive integer smaller than %d' % max_size)
except ValueError:
raise BadRequest('size must be a positive integer smaller than %d' % max_size)
return size
try:
leaderboards = LeaderboardsList.get(game)
is_above = (method_type == 'above')
if method_type == 'below' or is_above:
try:
score = float(params.get('score'))
score_time = float(params.get('time', 0))
if isinf(score) or isnan(score) or isinf(score_time) or isnan(score_time):
response.status_int = 400
return { 'ok': False, 'msg': 'Score or time are incorrectly formated' }
except (TypeError, ValueError):
response.status_int = 400
return {'ok': False, 'msg': 'Score or time parameter missing'}
return {'ok': True, 'data': leaderboards.get_page(key,
get_current_user(),
get_size(5, cls.max_page_size),
is_above,
score,
score_time)}
if method_type == 'near':
return {'ok': True, 'data': leaderboards.get_near(key,
get_current_user(),
get_size(9, cls.max_near_size))}
else: # method_type == 'top'
return {'ok': True, 'data': leaderboards.get_top_players(key,
get_current_user(),
get_size(9, cls.max_top_size))}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except LeaderboardError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def read_expanded(cls, slug, key):
game = get_game_by_slug(slug)
if game is None:
response.status_int = 404
return {'ok': False, 'msg': 'No game with that slug'}
params = request.GET
method_type = params.get('type', 'top')
def get_size(default_size, max_size):
try:
size = int(params.get('size', default_size))
if size <= 0 or size > max_size:
raise BadRequest('size must be a positive integer smaller than %d' % max_size)
except ValueError:
raise BadRequest('size must be a positive integer smaller than %d' % max_size)
return size
try:
leaderboards = LeaderboardsList.get(game)
is_above = (method_type == 'above')
if method_type == 'below' or is_above:
try:
score = float(params.get('score'))
score_time = float(params.get('time', 0))
if isinf(score) or isnan(score) or isinf(score_time) or isnan(score_time):
response.status_int = 400
return { 'ok': False, 'msg': 'Score or time are incorrectly formated' }
except (TypeError, ValueError):
response.status_int = 400
return {'ok': False, 'msg': 'Score or time parameter missing'}
return {'ok': True, 'data': leaderboards.get_page(key,
get_current_user(),
get_size(5, cls.max_page_size),
is_above,
score,
score_time)}
if method_type == 'near':
return {'ok': True, 'data': leaderboards.get_near(key,
get_current_user(),
get_size(9, cls.max_near_size))}
else: # method_type == 'top'
return {'ok': True, 'data': leaderboards.get_top_players(key,
get_current_user(),
get_size(9, cls.max_top_size))}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except LeaderboardError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def create_session(cls, slug, mode=None):
"""
Returns application settings for local.
"""
game = get_game_by_slug(slug)
if not game:
response.status_int = 404
return {'ok': False, 'msg': 'Game does not exist: %s' % slug}
if 'canvas' == mode:
prefix = 'play/%s/' % slug
else:
prefix = ''
mapping_table = 'mapping_table.json'
if game:
mapping_table = str(game.mapping_table)
user = get_current_user()
game_session_list = GameSessionList.get_instance()
game_session_id = game_session_list.create_session(user, game)
StoreList.reset()
DataShareList.reset()
GameNotificationKeysList.reset()
return {
'ok': True,
'mappingTable':
{
'mappingTableURL': prefix + mapping_table,
'mappingTablePrefix': prefix + 'staticmax/',
'assetPrefix': 'missing/'
},
'gameSessionId': game_session_id
}
def destroy_session(cls):
"""
Ends a session started with create_session.
"""
try:
game_session_id = request.params['gameSessionId']
user = get_current_user()
game_session_list = GameSessionList.get_instance()
session = game_session_list.get_session(game_session_id)
if session is not None:
if session.user.username == user.username:
game_session_list.remove_session(game_session_id)
return {'ok': True}
else:
response.status_int = 400
return {
'ok':
False,
'msg':
"Attempted to end a session that is not owned by you"
}
else:
response.status_int = 400
return {
'ok': False,
'msg': 'No session with ID "%s" exists' % game_session_id
}
except TypeError, e:
response.status_int = 400
return {'ok': False, 'msg': 'Something is missing: %s' % str(e)}
def checkout_transaction(cls):
user = get_current_user()
try:
game_slug = request.POST['gameSlug']
transaction_items_json = request.POST['basket']
except KeyError as e:
response.status_int = 400
return {'ok': False, 'msg': 'Missing parameter %s' % str(e)}
try:
transaction_items = _json_decoder.decode(transaction_items_json)
except JSONDecodeError as e:
response.status_int = 400
return {'ok': False, 'msg': 'Basket parameter JSON error: %s' % str(e)}
if not isinstance(transaction_items, dict):
response.status_int = 400
return {'ok': False, 'msg': 'Basket parameter JSON must be a dictionary'}
game = get_game_by_slug(game_slug)
if game is None:
response.status_int = 404
return {'ok': False, 'msg': 'No game with slug %s' % game_slug}
try:
transaction = Transaction(user, game, transaction_items)
return {'ok': True, 'data': {'transactionId': transaction.id}}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except StoreError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def badges_user_list(cls, slug=None):
try:
game = get_game_by_slug(slug)
if game is None:
raise ApiException('No game with that slug')
# get the user from the environment
# get a user model (simulation)
user = get_current_user()
# try to get a user_id from the context
badges_obj = Badges.get_singleton(game)
badges = badges_obj.badges
badges_total_dict = dict((b['key'], b.get('total')) for b in badges)
userbadges = badges_obj.find_userbadges_by_user(user.username)
for key, userbadge in userbadges.iteritems():
del userbadge['username']
try:
total = badges_total_dict[key]
except KeyError:
# the badge has been deleted or its key renamed so we just skip it
continue
userbadge['total'] = total
userbadge['achieved'] = (userbadge['current'] >= total)
response.status_int = 200
return {'ok': True, 'data': userbadges.values()}
except BadgesUnsupportedException:
return {'ok': False, 'data': []}
except ApiException as message:
response.status_int = 404
return {'ok': False, 'msg': str(message)}
def get_user(cls):
username = get_current_user().username
# 315569260 seconds = 10 years
response.set_cookie('local',
username,
httponly=False,
max_age=315569260)
return {'ok': True, 'data': {'username': username}}
def user(cls):
user = get_current_user()
user_profile = {'username': user.username,
'displayname': user.username,
'age': user.age,
'language': user.language,
'country': user.country,
'avatar': user.avatar}
return {'ok': True, 'data': user_profile}
def user(cls):
user = get_current_user()
user_profile = {'username': user.username,
'displayname': user.username,
'age': user.age,
'language': user.language,
'country': user.country,
'avatar': user.avatar,
'guest': user.guest}
return {'ok': True, 'data': user_profile}
def set_properties(cls, slug, datashare_id, params=None):
game = get_game_by_slug(slug)
datashare = DataShareList.get(game).get(datashare_id)
if 'joinable' in params:
try:
joinable = asbool(params['joinable'])
except ValueError:
raise BadRequest('Joinable must be a boolean value')
datashare.set_joinable(get_current_user(), joinable)
return {'ok': True}
def set_properties(cls, slug, datashare_id, params=None):
game = get_game_by_slug(slug)
datashare = DataShareList.get(game).get(datashare_id)
if 'joinable' in params:
try:
joinable = asbool(params['joinable'])
except ValueError:
raise BadRequest('Joinable must be a boolean value')
datashare.set_joinable(get_current_user(), joinable)
return {'ok': True}
def find(cls, slug):
game = get_game_by_slug(slug)
username = request.params.get('username')
datashares = DataShareList.get(game).find(get_current_user(),
username_to_find=username)
return {
'ok': True,
'data': {
'datashares':
[datashare.summary_dict() for datashare in datashares]
}
}
def read_transaction_status(cls, transaction_id):
user = get_current_user()
try:
user_transactions = UserTransactionsList.get(user)
transaction = user_transactions.get_transaction(transaction_id)
return {'ok': True, 'data': transaction.status()}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except StoreError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def read_transaction_status(cls, transaction_id):
user = get_current_user()
try:
user_transactions = UserTransactionsList.get(user)
transaction = user_transactions.get_transaction(transaction_id)
return {'ok': True, 'data': transaction.status()}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except StoreError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def read_overview(cls, slug):
game = get_game_by_slug(slug)
if game is None:
response.status_int = 404
return {'ok': False, 'msg': 'No game with that slug'}
try:
leaderboards = LeaderboardsList.get(game)
return {'ok': True, 'data': leaderboards.read_overview(get_current_user())}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except LeaderboardError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def read_overview(cls, slug):
game = get_game_by_slug(slug)
if game is None:
response.status_int = 404
return {'ok': False, 'msg': 'No game with that slug'}
try:
leaderboards = LeaderboardsList.get(game)
return {'ok': True, 'data': leaderboards.read_overview(get_current_user())}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except LeaderboardError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def remove_all(cls, slug):
user = get_current_user()
game = get_game_by_slug(slug)
if game is None:
response.status_int = 404
return {'ok': False, 'msg': 'No game with slug %s' % slug}
try:
store = StoreList.get(game)
store.get_store_user(user).remove_items()
return {'ok': True}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except StoreError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def remove_all(cls, slug):
user = get_current_user()
game = get_game_by_slug(slug)
if game is None:
response.status_int = 404
return {'ok': False, 'msg': 'No game with slug %s' % slug}
try:
store = StoreList.get(game)
store.get_store_user(user).remove_items()
return {'ok': True}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except StoreError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def read_user_items(cls, slug):
user = get_current_user()
game = get_game_by_slug(slug)
if game is None:
response.status_int = 404
return {'ok': False, 'msg': 'No game with slug %s' % slug}
try:
store = StoreList.get(game)
store_user = store.get_store_user(user)
return {'ok': True, 'data': {'userItems': store_user.get_items()}}
except StoreUnsupported:
return {'ok': True, 'data': {'userItems': {}}}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except StoreError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def read_user_items(cls, slug):
user = get_current_user()
game = get_game_by_slug(slug)
if game is None:
response.status_int = 404
return {'ok': False, 'msg': 'No game with slug %s' % slug}
try:
store = StoreList.get(game)
store_user = store.get_store_user(user)
return {'ok': True, 'data': {'userItems': store_user.get_items()}}
except StoreUnsupported:
return {'ok': True, 'data': {'userItems': {}}}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except StoreError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def create_session(cls, slug, mode=None):
"""
Returns application settings for local.
"""
game = get_game_by_slug(slug)
if not game:
response.status_int = 404
return {'ok': False, 'msg': 'Game does not exist: %s' % slug}
if 'canvas' == mode:
prefix = 'play/%s/' % slug
else:
prefix = ''
mapping_table = 'mapping_table.json'
if game:
mapping_table = str(game.mapping_table)
user = get_current_user()
game_session_list = GameSessionList.get_instance()
if asbool(request.params.get('closeExistingSessions', False)):
game_session_list.remove_game_sessions(user, game)
game_session = game_session_list.create_session(user, game)
# Reset API's (so YAML files are reloaded on a page refresh)
StoreList.reset()
DataShareList.reset()
GameNotificationKeysList.reset()
return {
'ok': True,
'mappingTable':
{
'mappingTableURL': prefix + mapping_table,
'mappingTablePrefix': prefix + 'staticmax/',
'assetPrefix': 'missing/'
},
'gameSessionId': game_session.gamesession_id
}
def checkout_transaction(cls):
user = get_current_user()
try:
game_slug = request.POST['gameSlug']
transaction_items_json = request.POST['basket']
except KeyError as e:
response.status_int = 400
return {'ok': False, 'msg': 'Missing parameter %s' % str(e)}
try:
transaction_items = _json_decoder.decode(transaction_items_json)
except JSONDecodeError as e:
response.status_int = 400
return {
'ok': False,
'msg': 'Basket parameter JSON error: %s' % str(e)
}
if not isinstance(transaction_items, dict):
response.status_int = 400
return {
'ok': False,
'msg': 'Basket parameter JSON must be a dictionary'
}
game = get_game_by_slug(game_slug)
if game is None:
response.status_int = 404
return {'ok': False, 'msg': 'No game with slug %s' % game_slug}
try:
transaction = Transaction(user, game, transaction_items)
return {'ok': True, 'data': {'transactionId': transaction.id}}
except ValidationException as e:
response.status_int = 400
return {'ok': False, 'msg': str(e)}
except StoreError as e:
response.status_int = e.response_code
return {'ok': False, 'msg': str(e)}
def create_session(cls, slug, mode=None):
"""
Returns application settings for local.
"""
game = get_game_by_slug(slug)
if not game:
response.status_int = 404
return {'ok': False, 'msg': 'Game does not exist: %s' % slug}
if 'canvas' == mode:
prefix = 'play/%s/' % slug
else:
prefix = ''
mapping_table = 'mapping_table.json'
if game:
mapping_table = str(game.mapping_table)
user = get_current_user()
game_session_list = GameSessionList.get_instance()
if (asbool(request.params.get('closeExistingSessions', False))):
game_session_list.remove_game_sessions(user, game)
game_session = game_session_list.create_session(user, game)
# Reset API's (so YAML files are reloaded on a page refresh)
StoreList.reset()
DataShareList.reset()
GameNotificationKeysList.reset()
return {
'ok': True,
'mappingTable': {
'mappingTableURL': prefix + mapping_table,
'mappingTablePrefix': prefix + 'staticmax/',
'assetPrefix': 'missing/'
},
'gameSessionId': game_session.gamesession_id
}
def destroy_session(cls):
"""
Ends a session started with create_session.
"""
try:
game_session_id = request.params['gameSessionId']
user = get_current_user()
game_session_list = GameSessionList.get_instance()
session = game_session_list.get_session(game_session_id)
if session is not None:
if session.user.username == user.username:
game_session_list.remove_session(game_session_id)
return {'ok': True}
else:
response.status_int = 400
return {'ok': False, 'msg': "Attempted to end a session that is not owned by you"}
else:
response.status_int = 400
return {'ok': False, 'msg': 'No session with ID "%s" exists' % game_session_id}
except TypeError, e:
response.status_int = 400
return {'ok': False, 'msg': 'Something is missing: %s' % str(e)}
def create(cls, slug):
game = get_game_by_slug(slug)
datashare = DataShareList.get(game).create_datashare(get_current_user())
return {'ok': True, 'data': {'datashare': datashare.summary_dict()}}
def _get_user_name():
return get_current_user().username
def find(cls, slug):
game = get_game_by_slug(slug)
username = request.params.get('username')
datashares = DataShareList.get(game).find(get_current_user(), username_to_find=username)
return {'ok': True, 'data': {'datashares': [datashare.summary_dict() for datashare in datashares]}}
def create(cls, slug):
game = get_game_by_slug(slug)
datashare = DataShareList.get(game).create_datashare(
get_current_user())
return {'ok': True, 'data': {'datashare': datashare.summary_dict()}}
def leave(cls, slug, datashare_id):
game = get_game_by_slug(slug)
DataShareList.get(game).leave_datashare(get_current_user(), datashare_id)
return {'ok': True}
def leave(cls, slug, datashare_id):
game = get_game_by_slug(slug)
DataShareList.get(game).leave_datashare(get_current_user(),
datashare_id)
return {'ok': True}
def game_auth_token(cls, slug):
user = get_current_user()
secret = slug
expTime = time() + 3 * 60
jwtPayload = jwt.encode({'username': user.username, 'exp': expTime}, secret)
return {'ok': True, 'data': jwtPayload}
def join(cls, slug, datashare_id):
game = get_game_by_slug(slug)
datashare = DataShareList.get(game).get(datashare_id)
datashare.join(get_current_user())
return {'ok': True, 'data': {'users': datashare.users}}
def get_user(cls):
username = get_current_user().username
# 315569260 seconds = 10 years
response.set_cookie('local', username, httponly=False, max_age=315569260)
return {'ok': True, 'data': {'username': username}}
def join(cls, slug, datashare_id):
game = get_game_by_slug(slug)
datashare = DataShareList.get(game).get(datashare_id)
datashare.join(get_current_user())
return {'ok': True, 'data': {'users': datashare.users}}
