def default_values(self): "Set some default values in the database" # Add some information box = hub.getConnection() t1 = Team(city='Pittsburgh', nickname='Ferrous Metals') box.memorize(t1) t2 = Team(city='Seattle', nickname='Seagulls') box.memorize(t2) p1 = Player(name='Bob Waffleburger', birthdate=datetime.date(1982,3,2), points=21) box.memorize(p1) p2 = Player(name='Mike Handleback', birthdate=datetime.date(1975,9,25), points=10) box.memorize(p2) p1.team = t1.ID p2.team = t2.ID # Add a default Page page = Page( pagename="FrontPage", data="This is the main page, please edit it." ) box.memorize( page ) # Setup identity data jrodrigo = TG_User( user_name = "jrodrigo" ) box.memorize( jrodrigo ) jrodrigo.password = "******" root = TG_User( user_name = "root" ) box.memorize( root ) root.password = "******" user = TG_Group( group_name = "user" ) box.memorize( user ) admin = TG_Group( group_name = "admin" ) box.memorize( admin ) format = TG_Permission( permission_name = "format" ) box.memorize( format ) ls = TG_Permission( permission_name = "ls" ) box.memorize( ls ) cat = TG_Permission( permission_name = "cat" ) box.memorize( cat ) o = TG_UserGroup( user_id = root.user_id, group_id = user.group_id ) box.memorize( o ) o = TG_UserGroup( user_id = root.user_id, group_id = admin.group_id ) box.memorize( o ) o = TG_UserGroup( user_id = jrodrigo.user_id, group_id = user.group_id ) box.memorize( o ) o = TG_GroupPermission( group_id = admin.group_id, permission_id = format.permission_id ) box.memorize( o ) o = TG_GroupPermission( group_id = user.group_id, permission_id = ls.permission_id ) box.memorize( o ) o = TG_GroupPermission( group_id = user.group_id, permission_id = cat.permission_id ) box.memorize( o ) return "done"
def setUp(self):
self.player_1_id = ObjectId()
self.player_1_name = 'gaR'
self.player_1_aliases = ['gar', 'garr', 'garpr']
self.player_1_rating = {
'norcal': Rating(),
'texas': Rating(mu=10., sigma=1.)
}
self.player_1_regions = ['norcal', 'texas']
self.player_2_id = ObjectId()
self.player_2_name = 'MIOM | SFAT'
self.player_2_aliases = ['miom | sfat', 'sfat', 'miom|sfat']
self.player_2_rating = {'norcal': Rating(mu=30., sigma=2.)}
self.player_2_regions = ['norcal', 'socal']
self.player_1 = Player(name=self.player_1_name,
aliases=self.player_1_aliases,
ratings=self.player_1_rating,
regions=self.player_1_regions,
id=self.player_1_id)
self.player_1_missing_id = Player(name=self.player_1_name,
aliases=self.player_1_aliases,
ratings=self.player_1_rating,
regions=self.player_1_regions)
self.player_2 = Player(name=self.player_2_name,
aliases=self.player_2_aliases,
ratings=self.player_2_rating,
regions=self.player_2_regions,
id=self.player_2_id)
self.player_1_json_dict = {
'_id': self.player_1_id,
'name': self.player_1_name,
'aliases': self.player_1_aliases,
'ratings': {
region: rating.dump()
for region, rating in self.player_1_rating.iteritems()
},
'regions': self.player_1_regions,
'merge_children': [self.player_1_id],
'merge_parent': None,
'merged': False,
}
self.player_1_json_dict_missing_id = {
'name': self.player_1_name,
'aliases': self.player_1_aliases,
'ratings': {
region: rating.dump()
for region, rating in self.player_1_rating.iteritems()
},
'regions': self.player_1_regions,
'merge_children': [None],
'merge_parent': None,
'merged': False,
}
def build(self, testMode=True):
"""
Initiate objects and views.
"""
''' init game objects '''
self.deck = Deck()
self.evaluator = Evaluator()
self.player = []
self.player.append(Player(0))
self.player.append(Player(1))
# board stands for public cards on board
self.board = Board()
# In test mode, both player select right-most cards for the turn automatically
self.testMode = testMode
''' create view objects '''
# Scatter that can be rotated to display players
scatter_bot = ScatterLayout(do_rotation=False,
do_translation=False,
do_scale=False,
size_hint=(1, 1),
pos_hint={
'x': 0,
'y': 0
},
rotation=0)
# For player on top, the widget rotates 180 degree
scatter_top = ScatterLayout(do_rotation=False,
do_translation=False,
do_scale=False,
size_hint=(1, 1),
pos_hint={
'x': 0,
'y': 0
},
rotation=180)
box = PlayerDeck()
box2 = PlayerDeck()
publicArea = PublicArea()
box.build(self, "player1", 0, self.testMode)
box2.build(self, "player2", 1, self.testMode)
publicArea.build()
scatter_bot.add_widget(box)
scatter_top.add_widget(box2)
self.add_widget(scatter_bot)
self.add_widget(scatter_top)
self.add_widget(publicArea)
# register id of view objects
self.ids[box.id] = box
self.ids[box2.id] = box2
self.ids[publicArea.id] = publicArea
def add_player(name, index_str):
if index_str:
player = Player(name, int(index_str))
game.add_player(player)
msg = f'Player {name} has been added with index {index_str}'
else:
player = Player(name)
game.add_player(player)
msg = f'Player {name} has been added'
return display.message(msg, ''), 202
def init_game(request):
print "Init game..."
player1 = Player("Player 1")
player2 = Player("Player 2")
game = Game(player1, player2)
# Store game object to session
request.session['game'] = game
# Print game id for DEBUG
print game.id()
return game.toJSON()
def setUp(self):
self.player_1_id = ObjectId()
self.player_2_id = ObjectId()
self.region_id = 'norcal'
self.player_1 = Player(
'gaR', ['gar', 'garr'],
{'norcal': TrueskillRating(), 'texas': TrueskillRating()},
False, id=self.player_1_id)
self.player_2 = Player(
'sfat', ['sfat', 'miom | sfat'],
{'norcal': TrueskillRating(), 'socal': TrueskillRating()},
False, id=self.player_2_id)
def test_update_player(self):
self.assertEquals(self.norcal_dao.get_player_by_id(self.player_1_id),
self.player_1)
self.assertEquals(self.norcal_dao.get_player_by_id(self.player_2_id),
self.player_2)
self.assertEquals(self.norcal_dao.get_player_by_id(self.player_3_id),
self.player_3)
player_1_clone = Player(name='gaR',
aliases=['gar', 'garr'],
ratings={
'norcal': Rating(),
'texas': Rating()
},
regions=['norcal', 'texas'],
id=self.player_1_id)
player_1_clone.name = 'garrr'
player_1_clone.aliases.append('garrr')
del player_1_clone.ratings['texas']
self.assertNotEquals(
self.norcal_dao.get_player_by_id(self.player_1_id), player_1_clone)
self.norcal_dao.update_player(player_1_clone)
self.assertNotEquals(
self.norcal_dao.get_player_by_id(self.player_1_id), self.player_1)
self.assertEquals(self.norcal_dao.get_player_by_id(self.player_2_id),
self.player_2)
self.assertEquals(self.norcal_dao.get_player_by_id(self.player_3_id),
self.player_3)
self.assertEquals(self.norcal_dao.get_player_by_id(self.player_1_id),
player_1_clone)
def dispatch(self, message):
try:
request = json.loads(message.body)
assert isinstance(request, dict), 'Request should be a dict().'
assert 'request' in request, 'Required argument is missing: "request".'
method_name = str(request['request'])
assert not method_name.startswith(
'_'), 'You are not allowed to call private API.'
f = getattr(controller, method_name, None)
assert callable(f), 'You are requesting an unknown API.'
# Get Player record from server.
sender = db.IM('xmpp', message.sender.split('/')[0])
player = Player.all().filter('account =', sender).fetch(limit=1)
if len(player) == 0: # Create a new record for new Player.
player = Player(account=sender)
player.put()
else:
player = player[0]
assert player is not None, 'Failed to get player data.'
# Take action
arg = request['arg'] if 'arg' in request else {}
assert isinstance(arg, dict), 'Arguments should be a dict()'
arg['sender'] = player # append sender to arguments
result = f(arg)
except AssertionError, e:
result = json.dumps({
'response':
method_name if 'method_name' in locals() else 'unknown',
'stat':
'fail',
'msg':
str(e)
})
def add_user(self):
user = User(self)
db_session.add(user)
# there should be improved to ensure User and Player have same user_id
db_session.add(Player(nickname=self.username.data))
db_session.commit()
return user
def join_game(self):
"""
Join game
"""
response = self.send_message("/games/{0}/players?name={1}".format(
self.gameid, self.name))
player = Player(**response)
self.uuid = player.uuid
def prepare_game(self):
maze_map = MazeMap(self.map_width, self.map_heigth, self.start_point, self.finish_point)
maze_map.generate_maze()
maze_map.populate_borders()
player = Player(self.start_point, maze_map, self.player_vision)
maze_map.place_player(player)
self.prepared_map = maze_map
self.set_up_player = player
self.displayer = Displayer(self.prepared_map)
def setUp(self):
self.player_1_id = ObjectId()
self.player_2_id = ObjectId()
self.region_id = 'norcal'
self.player_1 = Player(name='gaR',
aliases=['gar', 'garr'],
ratings={
'norcal': Rating(),
'texas': Rating()
},
id=self.player_1_id)
self.player_2 = Player(name='sfat',
aliases=['sfat', 'miom | sfat'],
ratings={
'norcal': Rating(),
'socal': Rating()
},
id=self.player_2_id)
def create_game(
players_info: dict,
num_disasters: int,
num_catastrophes: int,
num_safe: int,
) -> Game:
if num_safe < SHOP_SIZE:
raise RuntimeError("At least the first shop must be safe")
deck = []
for room_id in ROOM_LIST:
room = int(room_id)
if room < THRONE_ROOM_ID_START:
deck.append(room)
random.shuffle(deck)
safe = deck[:num_safe]
deck = deck[num_safe:]
disasters = []
catastrophes = []
for card in DISASTER_LIST:
if card[0] == "d":
disasters += [card]
elif card[0] == "c":
catastrophes += [card]
deck += random.sample(disasters, num_disasters) + random.sample(
catastrophes, num_catastrophes)
random.shuffle(deck)
deck = deck + safe
shop = []
while len(shop) < SHOP_SIZE:
shop.append(deck.pop())
players = {}
for player_id in players_info:
info = players_info[player_id]
players[player_id] = Player(
info["username"],
int(info["throne_room_id"]),
Castle(int(info["throne_room_id"])).to_json_obj(),
[],
)
turn_order = [player_id for player_id in players_info]
random.shuffle(turn_order)
return Game(
players,
turn_order,
0,
shop,
[],
deck,
num_disasters,
num_catastrophes,
[],
[],
)
def test_get_players_with_similar_alias_match_name(self):
player = Player(name='ivanvan',
aliases=['asdf'],
ratings={
'norcal': Rating(),
'texas': Rating()
},
regions=['norcal', 'texas'],
id=ObjectId())
self.norcal_dao.insert_player(player)
self.assertEquals(
self.norcal_dao.get_players_with_similar_alias('ivanvan'),
[player])
def get_captain_by_game_id(gid: str) -> Player:
"""
The captain of the game
"""
query = f"SELECT player.* FROM player " \
f"INNER JOIN game ON game.id = player.gid " \
f"WHERE game.id = '{gid}' AND player.id = game.captain_id"
res = conn.execute(query).fetchone()
if res:
return Player(*res)
else:
return None
def player_info():
"""Get player info and pass to new route"""
player_name = request.args.get('name')
password = request.args.get('password')
if password == 'bruder2020':
player = Player(player_name=player_name, password=password)
db.session.add(player)
db.session.commit()
return redirect(url_for('player', name=player.player_name))
if password == 'lizhost':
return redirect(url_for('player', name='host'))
else:
return redirect('/')
def to_player(json_dict: dict) -> Player:
"""
Converts json dictionary to Player object
:param json_dict:
:return:
"""
if json_dict is None:
return None
result = Player(json_dict['name'], json_dict['position'],
json_dict['jerseyNumber'], json_dict['dateOfBirth'],
json_dict['nationality'], json_dict['contractUntil'],
json_dict['marketValue'])
return result
def main():
game_service = GameService()
board_size = int(input('Please Enter board size: '))
num_players = int(input('Please enter number of players: '))
players_list = []
for num in range(num_players):
player_name = input(f'Please enter {num} player name: ')
players_list.append(Player(player_name))
game_service.initialize_board(board_size, players_list)
game_service.play_game()
def __init__(self):
self.roundsPlayed = 0
playersPool = [ Player([], 1500, 0, "PLayer_unu"),
Player([], 1500, 1, "GigiKent"),
Player([], 1500, 2, "GGValuta"),
Player([], 1500, 3, "AmTalent"),
Player([], 1500, 4, "SefuLaBani"),
Player([], 1500, 5, "SerifIntergalactic"),
Player([], 1500, 6, "Bombardieru"),
Player([], 1500, 7, "Bo$$uLaPoker"),
Player([], 1500, 8, "DauGherle")]
self.players = []
for i in range(MAX_PLAYERS):
self.players.append(playersPool[i])
self.dealer = -1
self.actingPlayer = -1
self.firstToAct = -1
self.blindIndex = 0
self.state = GameState.InitRound
self.waitingHumanInput = False
def add_player():
"""
We create a player with his name and lastname if the request is in POST
if it's in GET it only shows the template
"""
form = Form_add_players(request.form)
if form.validate_on_submit():
name_player = form.name_player.data
lastname_player = form.last_name_player.data
player = Player(name=name_player, lastname=lastname_player)
db.session.add(player)
db.session.commit()
return redirect(url_for('.show_players'))
else:
return render_template("add_player.html", form=form)
def load_data(self):
"""
from namelist.csv load data, if encoding get wrong, try to change form ut8-sig to utf-8
:return:
"""
if not os.path.exists('namelist.csv'):
msg = QMessageBox.question(self, "警告", "未找到namelist.csv",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No) # 这里是固定格式，yes/no不能动
return msg
with open('namelist.csv', 'r') as f:
lines = csv.reader(f)
self.namelist = []
for line in lines:
# log(line)
# log(len(line))
if not (len(line) > 3 and line[-1] != ''):
self.namelist.append(Player(line[0], line[1], line[2]))
def pridobi_igralce():
seznam = []
nadaljuj = True
while nadaljuj and len(seznam) < 9:
print('Ali želite dodati igralca?')
print('1) Da')
print('2) Ne')
odgovor = input('> ')
if odgovor == '2':
nadaljuj = False
elif odgovor == '1':
ime = input('Vpišite ime igralca: ')
stack = pridobi_stack()
seznam.append(Player(ime, stack))
else:
print('Neveljaven odgovor!')
pass
return seznam
def load_players():
"""Load players from u.player into database."""
print("Players")
# Player.query.delete()
for row in open("seed_data/u.player"):
row = row.rstrip()
player_id, user_id, games_played, games_not_played = row.split("|")
player = Player(player_id=player_id,
user_id=user_id,
games_played=games_played,
games_not_played=games_not_played)
db.session.add(player)
db.session.commit()
def create_player(load_weights=True, user_model=False):
env = create_env()
env.reset()
# Get screen size so that we can initialize layers correctly based on shape
# returned from AI gym. Typical dimensions at this point are close to 3x40x90
# which is the result of a clamped and down-scaled render buffer in get_screen()
init_screen = get_screen(env)
_, n_channels, screen_height, screen_width = init_screen.shape # 3, 40, 60
if user_model:
policy_net = DQNUser(screen_height, screen_width, n_actions,
KERNEL_SIZE, N_LAYERS).to(device)
policy_net.eval()
target_net = DQNUser(screen_height, screen_width, n_actions,
KERNEL_SIZE, N_LAYERS).to(device)
target_net.eval()
else:
policy_net = DQN(screen_height, screen_width, n_actions).to(device)
policy_net.eval()
target_net = DQN(screen_height, screen_width, n_actions).to(device)
target_net.eval()
if load_weights:
model_dir = "models"
model_file_name = "mean100_659.pth"
policy_net.load_state_dict(
torch.load(f"{model_dir}/{model_file_name}", map_location='cpu'))
target_net.load_state_dict(policy_net.state_dict())
optimizer = optim.Adam(policy_net.parameters(),
lr=LEARNING_RATE,
weight_decay=1e-6)
scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9999999)
memory = ReplayMemory(REPLAY_MEM)
fake_memory = ReplayMemory(REPLAY_MEM)
player = Player(env, policy_net, target_net, optimizer, scheduler, memory,
fake_memory)
return player
def record_game_completed():
# Get game ID from game.html
game_id = request.args.get('game_id')
# Get user ID from session
user_id = session['active_session']
# Query to see if player and game are already in player database
player_game_record = db.session.query(Player).filter(
Player.user_id == user_id, Player.games_played == game_id).first()
print(player_game_record)
# If statement to add if record doesn't exist, flash message if already in database
if player_game_record is None:
alert_mssg = 'Congrats on solving this game!'
record_game = Player(user_id=user_id, games_played=game_id)
db.session.add(record_game)
db.session.commit()
else:
alert_mssg = 'Congrats on solving this game again!'
return jsonify(alert_mssg)
def __init__(self, playerFile, exclusionFile):
self.playerFile = playerFile
self.exclusionFile = exclusionFile
players = []
exclusions = []
# First name, Last name, Email
for row in csv.reader(self.playerFile):
assert len(row) == 3
players.append(Player(*row))
# Firstname lastname, Firstname lastname
for row in csv.reader(self.exclusionFile):
assert len(row) == 2
g, r = row
# Verify players
gifterExclusion = (x for x in players if x.getname() == g).next()
receiverExclusion = (x for x in players if x.getname() == r).next()
exclusions.append((gifterExclusion, receiverExclusion))
self.players = players
self.exclusions = exclusions
def __parse_team_table_row(table_row):
row = str(table_row.strip())
row_in_tab = re.split('row_cell', row)
read = 0
player_data = []
for r in row_in_tab:
re_object = re.search(r'playerid/\d+.*">', r)
if re.search(r'">(\d+)%', r):
data = re.search(r'">(\d+)%', r)
player_data.append(data.groups(0)[0])
read += 1
elif re.search(r'rating_(\d+).png', r):
data = re.search(r'rating_(\d+).png', r)
player_data.append(data.groups(0)[0])
read += 1
elif re.search(r'">\$ ([0-9,]+)</div>', r):
data = re.search(r'">\$ ([0-9,]+)</div>', r)
player_data.append(data.groups(0)[0])
read += 1
elif re.search(r'">(.+)</span>', r):
data = re.search(r'<span.*">(.+)</span>', r)
player_data.append(data.groups(0)[0])
read += 1
elif read > 0:
data = re.search(r'">(\w+)</div>', r)
player_data.append(data.groups(0)[0])
read += 1
elif re_object:
read = 1
player_id = re.search(r'playerid/(\d+).*">', r)
player_data.append(player_id.groups(0)[0])
player_name = re.search(r'playerid/\d+.*">(.*)</a>', r)
player_data.append(player_name.groups(0)[0])
player = Player(int(player_data[0]), player_data[1], player_data[2],
int(player_data[3]), float(player_data[4]),
int(player_data[5]), player_data[6], player_data[7])
return player
def _map_init(self, map_msg):
row_num = map_msg["rows"]
col_num = map_msg["cols"]
input_cells = [[Cell(row=row, col=col) for col in range(col_num)] for row in range(row_num)]
paths = [Path(id=path["id"], cells=[input_cells[cell["row"]][cell["col"]] for cell in path["cells"]]
) for path in map_msg["paths"]]
kings = [King(player_id=king["playerId"], center=input_cells[king["center"]["row"]][king["center"]["col"]],
hp=king["hp"],
attack=king["attack"], range=king["range"], target=None, target_cell=None, is_alive=True)
for king in map_msg["kings"]]
self.players = [Player(player_id=map_msg["kings"][i]["playerId"], king=kings[i], deck=[],
hand=[], ap=self.game_constants.max_ap,
paths_from_player=self._get_paths_starting_with(kings[i].center, paths),
path_to_friend=self._find_path_starting_and_ending_with(kings[i].center,
kings[i ^ 1].center, paths),
units=[], cast_area_spell=None, cast_unit_spell=None,
duplicate_units=[],
hasted_units=[],
played_units=[],
died_units=[],
range_upgraded_unit=None,
damage_upgraded_unit=None,
spells=[]) for i in range(4)]
for player in self.players:
player.paths_from_player.remove(player.path_to_friend)
self.player = self.players[0]
self.player_friend = self.players[1]
self.player_first_enemy = self.players[2]
self.player_second_enemy = self.players[3]
self.map = Map(row_num=row_num, col_num=col_num, paths=paths, kings=kings, cells=input_cells, units=[])
def setUp(self):
self.mongo_client.drop_database(DATABASE_NAME)
self.player_1_id = ObjectId()
self.player_2_id = ObjectId()
self.player_3_id = ObjectId()
self.player_4_id = ObjectId()
self.player_5_id = ObjectId()
self.player_1 = Player(name='gaR',
aliases=['gar', 'garr'],
ratings={
'norcal': Rating(),
'texas': Rating()
},
regions=['norcal', 'texas'],
id=self.player_1_id)
self.player_2 = Player(name='sfat',
aliases=['sfat', 'miom | sfat'],
ratings={'norcal': Rating()},
regions=['norcal'],
id=self.player_2_id)
self.player_3 = Player(name='mango',
aliases=['mango', 'gar'],
ratings={'norcal': Rating(mu=2, sigma=3)},
regions=['socal'],
id=self.player_3_id)
self.player_4 = Player(name='shroomed',
aliases=['shroomed'],
ratings={'norcal': Rating()},
regions=['norcal'],
id=self.player_4_id)
self.player_5 = Player(name='pewpewu',
aliases=['pewpewu'],
ratings={'norcal': Rating()},
regions=['norcal', 'socal'],
id=self.player_5_id)
self.merge_player_1 = Player(name='CLGsFaT',
aliases=['clg | sfat'],
ratings={'norcal': Rating()},
regions=['norcal'],
id=ObjectId())
# only includes players 1-3
self.players = [self.player_1, self.player_2, self.player_3]
self.tournament_id_1 = ObjectId()
self.tournament_type_1 = 'tio'
self.tournament_raw_id_1 = ObjectId()
self.tournament_date_1 = datetime(2013, 10, 16)
self.tournament_name_1 = 'tournament 1'
self.tournament_players_1 = [
self.player_1_id, self.player_2_id, self.player_3_id,
self.player_4_id
]
self.tournament_matches_1 = [
Match(winner=self.player_1_id, loser=self.player_2_id),
Match(winner=self.player_3_id, loser=self.player_4_id)
]
self.tournament_regions_1 = ['norcal']
# tournament 2 is earlier than tournament 1, but inserted after
self.tournament_id_2 = ObjectId()
self.tournament_type_2 = 'challonge'
self.tournament_raw_id_2 = ObjectId()
self.tournament_date_2 = datetime(2013, 10, 10)
self.tournament_name_2 = 'tournament 2'
self.tournament_players_2 = [
self.player_5_id, self.player_2_id, self.player_3_id,
self.player_4_id
]
self.tournament_matches_2 = [
Match(winner=self.player_5_id, loser=self.player_2_id),
Match(winner=self.player_3_id, loser=self.player_4_id)
]
self.tournament_regions_2 = ['norcal', 'texas']
self.tournament_1 = Tournament(id=self.tournament_id_1,
name=self.tournament_name_1,
type=self.tournament_type_1,
date=self.tournament_date_1,
regions=self.tournament_regions_1,
raw_id=self.tournament_raw_id_1,
players=self.tournament_players_1,
matches=self.tournament_matches_1)
self.tournament_2 = Tournament(id=self.tournament_id_2,
name=self.tournament_name_2,
type=self.tournament_type_2,
date=self.tournament_date_2,
regions=self.tournament_regions_2,
raw_id=self.tournament_raw_id_2,
players=self.tournament_players_2,
matches=self.tournament_matches_2)
self.tournament_ids = [self.tournament_id_1, self.tournament_id_2]
self.tournaments = [self.tournament_1, self.tournament_2]
self.pending_tournament_id_1 = ObjectId()
self.pending_tournament_type_1 = 'tio'
self.pending_tournament_raw_id_1 = ObjectId()
self.pending_tournament_date_1 = datetime(2013, 10, 11)
self.pending_tournament_name_1 = 'pending tournament 1'
self.pending_tournament_players_1 = [
self.player_1.name, self.player_2.name, self.player_3.name,
self.player_4.name
]
self.pending_tournament_matches_1 = [
AliasMatch(winner=self.player_1.name, loser=self.player_2.name),
AliasMatch(winner=self.player_3.name, loser=self.player_4.name)
]
self.pending_tournament_regions_1 = ['norcal']
self.pending_tournament_1 = PendingTournament(
id=self.pending_tournament_id_1,
name=self.pending_tournament_name_1,
type=self.pending_tournament_type_1,
date=self.pending_tournament_date_1,
regions=self.pending_tournament_regions_1,
raw_id=self.pending_tournament_raw_id_1,
players=self.pending_tournament_players_1,
matches=self.pending_tournament_matches_1)
self.pending_tournaments = [self.pending_tournament_1]
self.ranking_entry_1 = RankingEntry(rank=1,
player=self.player_1_id,
rating=20)
self.ranking_entry_2 = RankingEntry(rank=2,
player=self.player_2_id,
rating=19)
self.ranking_entry_3 = RankingEntry(rank=3,
player=self.player_3_id,
rating=17.5)
self.ranking_entry_4 = RankingEntry(rank=3,
player=self.player_4_id,
rating=16.5)
self.ranking_time_1 = datetime(2013, 4, 20)
self.ranking_time_2 = datetime(2013, 4, 21)
self.ranking_1 = Ranking(id=ObjectId(),
region='norcal',
time=self.ranking_time_1,
tournaments=self.tournament_ids,
ranking=[
self.ranking_entry_1,
self.ranking_entry_2, self.ranking_entry_3
])
self.ranking_2 = Ranking(id=ObjectId(),
region='norcal',
time=self.ranking_time_2,
tournaments=self.tournament_ids,
ranking=[
self.ranking_entry_1,
self.ranking_entry_2, self.ranking_entry_4
])
self.ranking_3 = Ranking(
id=ObjectId(),
region='norcal',
time=self.ranking_time_2,
tournaments=self.tournament_ids,
ranking=[self.ranking_entry_1, self.ranking_entry_2])
self.rankings = [self.ranking_1, self.ranking_2, self.ranking_3]
self.user_id_1 = 'abc123'
self.user_admin_regions_1 = ['norcal', 'texas']
self.user_1 = User(id=self.user_id_1,
admin_regions=self.user_admin_regions_1,
username='******',
salt='nacl',
hashed_password='******')
self.user_id_2 = 'asdfasdf'
self.user_full_name_2 = 'Full Name'
self.user_admin_regions_2 = []
self.user_2 = User(id=self.user_id_2,
admin_regions=self.user_admin_regions_2,
username=self.user_full_name_2,
salt='nacl',
hashed_password='******')
self.users = [self.user_1, self.user_2]
self.region_1 = Region(id='norcal', display_name='Norcal')
self.region_2 = Region(id='texas', display_name='Texas')
self.regions = [self.region_1, self.region_2]
for region in self.regions:
Dao.insert_region(region,
self.mongo_client,
database_name=DATABASE_NAME)
self.norcal_dao = Dao('norcal',
self.mongo_client,
database_name=DATABASE_NAME)
for player in self.players:
self.norcal_dao.insert_player(player)
for tournament in self.tournaments:
self.norcal_dao.insert_tournament(tournament)
for pending_tournament in self.pending_tournaments:
self.norcal_dao.insert_pending_tournament(pending_tournament)
for ranking in self.rankings:
self.norcal_dao.insert_ranking(ranking)
for user in self.users:
self.norcal_dao.insert_user(user)
def __init__(self):
self.view = View()
self.library = Library()
self.player = Player(self.library)
