def create_game(
league_id,
creator_id,
message,
metrics_by_opponent,
sport_id):
""" Create a Game and return it.
Required:
id league_id League id that Game belongs to
id creator_id Player id of Game's creator
str message Creator's message (headline)
dict metrics_by_opponent Metrics keyed on Opponent id
id sport_id Sport id for this Game
Return:
Game newly created Game
"""
# FIXME: how do we handle None properties?
if message is None:
message = "Good Game."
# TODO: when games have properties, fill these in!
#
#raw_properties = {}
#
#properties = SqNode.prepare_node_properties(
# Game.property_keys(),
# raw_properties)
# prepare a node prototype for this game
prototype_node = editor.prototype_node(
API_NODE_TYPE.GAME,
{API_NODE_PROPERTY.SPORT_ID: sport_id})
# prepare edge prototypes for schedule edges
prototype_edges = editor.prototype_edge_and_complement(
API_EDGE_TYPE.HAS_SCHEDULED,
{},
league_id)
# prepare edge prototypes for creator edges
prototype_edges.extend(editor.prototype_edge_and_complement(
API_EDGE_TYPE.CREATED,
{API_EDGE_PROPERTY.MESSAGE: message},
creator_id))
# prepare edge prototypes for result edges
for opponent_id, metrics in metrics_by_opponent.items():
for metric in metrics:
# TODO: handle other metrics besides ResultMetric
prototype_edges.extend(editor.prototype_edge_and_complement(
metric.result,
{},
opponent_id))
return editor.create_node_and_edges(prototype_node, prototype_edges)
def create_league(name, creator_id, opponent_ids=[]):
""" Create and return a League.
Required:
str name name of League to be created
id creator_id id of Person creating this League
Optional:
list opponent_ids ids of Teams/Players to add by default
Return:
League SqNode of Teams, Players, Schedules
"""
raw_properties = {
API_NODE_PROPERTY.NAME: name,
}
# squash the two into one set of flat, valid node properties
properties = League.prepare_node_properties(
League.property_keys(),
raw_properties)
# prepare a node prototype for this league
prototype_node = editor.prototype_node(
API_NODE_TYPE.LEAGUE,
properties)
# prepare edge prototypes for creator edges
# TODO: All creators to attach a message to league creation
prototype_edges = editor.prototype_edge_and_complement(
API_EDGE_TYPE.CREATED,
{},
creator_id)
# prepare edge prototypes for default opponents
for opponent_id in opponent_ids:
prototype_edges.extend(editor.prototype_edge_and_complement(
API_EDGE_TYPE.IN_LEAGUE,
{},
opponent_id))
return editor.create_node_and_edges(prototype_node, prototype_edges)
def create_user(
email,
password_hash,
referrer_url,
third_parties={},
inviter_id=None,
ip=PROPERTY_VALUE.EMPTY,
locale=PROPERTY_VALUE.EMPTY):
""" Create a User and return it.
Required:
str email created User's email
str password_hash created User's encrypted password
url referrer_url source link clicked to cause this
Optional:
dict third_parties key/val dicts keyed on 3rd party
id inviter_id User inviting/spawning User/Person
str ip User's IP, if logged in
str locale User's locale (ISO language+country)
Return:
User SqNode can log in, act as other SqNodes
Example:
Optional parameter third_parties should be defined as follows:
{
"fb" : {<CONVERT FROM JSON TO DICT AND LEAVE DATA AS IS>},
"tw" : {<CONVERT FROM JSON TO DICT AND LEAVE DATA AS IS>},
}
This will be flattened, validated, and culled by SqNode.
"""
# TODO: when there's an alternative to Facebook for login, revisit
# authorization logic. some of this logic might be context-dependent.
# email, password_hash, username, timezone, and locale are just being
# initialized for now; we get these values from Facebook, but they
# deserve placeholders in case we have to remove third party data.
# these properties are not explicitly required. one or more third
# parties may provide them instead.
raw_properties = {
API_NODE_PROPERTY.EMAIL: email,
API_NODE_PROPERTY.PASSWORD_HASH: password_hash,
}
# TODO: figure out what else to do with referrer_url
# no ip address would mean this user isn't logged in at creation time,
# in which case the initialized empty values suffice.
if ip:
current_ts = int(time.time())
raw_properties.update({
API_NODE_PROPERTY.REFERRER_URL: referrer_url,
API_NODE_PROPERTY.LAST_IP: ip,
API_NODE_PROPERTY.LOCALE: locale,
API_NODE_PROPERTY.LAST_LOGIN_TS: current_ts,
API_NODE_PROPERTY.LAST_AUTHORIZED_TS: current_ts,
})
# squash the two into one set of flat, valid node properties
properties = User.prepare_node_properties(
User.property_keys(),
raw_properties,
third_parties)
# TODO: add a static method call to generically check required fields
# against statically defined lists in each class.
# prepare a node prototype for this user
prototype_node = editor.prototype_node(
API_NODE_TYPE.USER,
properties)
# TODO: prepare an edge prototype for the inviter_id
return editor.create_node_and_edges(prototype_node, [])
def create_player(
first_name,
last_name,
spawner_id,
owner_id=None,
third_parties={}):
""" Create a Player and return it.
Required:
str first_name created Player's first name
str last_name created Player's last name
id spawner_id id of User creating this Player
Optional:
id owner_id id of User controlling this Player
dict third_parties key/val dicts keyed on 3rd party
Return:
Player is a Person, acts as an Opponent
Example:
Optional parameter third_parties should be defined as follows:
{
"fb" : {<CONVERT FROM JSON TO DICT AND LEAVE DATA AS IS>},
"tw" : {<CONVERT FROM JSON TO DICT AND LEAVE DATA AS IS>},
}
This will be flattened, validated, and culled by SqNode.
"""
player_keys = Player.property_keys()
# TODO: everything below should happen generically in Person._create()
#return Person.create(
# raw_properties,
# Player.property_keys(),
# spawner_id,
# owner_id,
# third_parties)
# FIXME: for now, we co-locate third party username/email with both
# the associated User and Person...it's kinda bad.
player_keys.extend([
API_NODE_PROPERTY.USERNAME,
API_NODE_PROPERTY.EMAIL,
])
raw_properties = {
API_NODE_PROPERTY.FIRST_NAME: first_name,
API_NODE_PROPERTY.LAST_NAME: last_name,
}
properties = Player.prepare_node_properties(
player_keys,
raw_properties,
third_parties)
# TODO: add a static method call to generically check required fields
# against statically defined lists in each class.
# prepare a node prototype for this game
prototype_node = editor.prototype_node(
API_NODE_TYPE.PLAYER,
properties)
# prepare edge prototypes for spawner edges
prototype_edges = editor.prototype_edge_and_complement(
API_EDGE_TYPE.SPAWNED,
{},
spawner_id)
if owner_id is None:
owner_id = spawner_id
# prepare edge prototypes for owner edges
prototype_edges.extend(editor.prototype_edge_and_complement(
API_EDGE_TYPE.OWNS,
{},
owner_id))
prototype_edges.append(editor.prototype_edge(
API_EDGE_TYPE.HAS_PRIMARY,
{},
None,
owner_id))
prototype_edges.append(editor.prototype_edge(
API_EDGE_TYPE.DEFAULTS_TO,
{},
owner_id,
None))
return editor.create_node_and_edges(prototype_node, prototype_edges)