def test_undo_match(g):
p = Player("test player")
p2 = Player("test player 2")
player_dao.create(p)
p.id = 1
player_dao.create(p2)
p2.id = 2
t = Tournament(0,'','T1','type',0)
tournament_dao.create(t)
t.id = 1
match_dao.create([p.id, p2.id], t.id)
match_id = 1
match = Match(player1=p,player2=p2,id=match_id)
match.score1 = 19
match.score2 = 21
match_dao.update(match)
match_dao.undo(match)
retrieved_match = match_dao.find(match_id)
matches = match_dao.find_by_tournament(t.id)
assert retrieved_match.score1 == 0
assert retrieved_match.score2 == 0
assert retrieved_match.player1.fname == p.fname
assert retrieved_match.player2.fname == p2.fname
assert retrieved_match.player1.id == p.id
assert retrieved_match.player2.id == p2.id
assert not matches[0].entered_time
def createTournament(request):
if request.method == 'POST':
form = CreateTournamentForm(request.POST, request.FILES)
if form.is_valid():
user = User.objects.get(user=request.user)
tournament = Tournament(
name=form.cleaned_data.get("name"),
start=form.cleaned_data.get("start"),
end=form.cleaned_data.get("end"),
username=user,
type=form.cleaned_data.get("type"),
file=request.FILES.get("file"),
description=form.cleaned_data.get("description"))
tournament.save()
Manager.objects.create(user_id=user, tournament=tournament)
return redirect('/user/')
else:
form = CreateTournamentForm()
return render_to_response('createtournament.html',
RequestContext(request, {
'form': form,
}))
def test_create_and_find_scheduled_by_tournament(g):
p = Player("test player")
p2 = Player("test player 2")
p3 = Player("test player 3")
player_dao.create(p)
p.id = 1
player_dao.create(p2)
p2.id = 2
player_dao.create(p3)
p3.id = 3
t = Tournament(0,'','T1','type',0)
tournament_dao.create(t)
t.id = 1
t2 = Tournament(0,'','T2','type',0)
tournament_dao.create(t2)
t2.id = 2
match_dao.create([p.id,p2.id], t.id)
match_dao.create([p.id,p2.id], t2.id)
match_dao.create([p.id,p3.id], t2.id)
retrieved_matches = match_dao.find_by_tournament(t2.id)
assert len(retrieved_matches) == 2
assert retrieved_matches[0].player2.fname == p2.fname
assert retrieved_matches[1].id == 3
def test_standings_with_games_not_played(g):
p = Player("test player")
p2 = Player("test player 2")
p3 = Player("test player 3")
player_dao.create(p)
p.id = 1
player_dao.create(p2)
p2.id = 2
player_dao.create(p3)
p3.id = 3
t = Tournament(0,'','T1','type',0)
tournament_dao.create(t)
t.id = 1
match_dao.create([p.id, p2.id], t.id)
match_dao.create([p.id, p3.id], t.id)
match_dao.create([p3.id, p2.id], t.id)
standings = standings_dao.find(t.id)
assert standings[0].win == 0
assert standings[0].loss == 0
assert standings[0].tie == 0
assert standings[1].win == 0
assert standings[1].loss == 0
assert standings[1].tie == 0
assert standings[2].win == 0
assert standings[2].loss == 0
assert standings[2].tie == 0
def scrape(self):
# Get tournament info
try:
results = requests.get(self.tournament_url)
except requests.exceptions.MissingSchema:
results = requests.get("http://{}".format(self.tournament_url))
results_tree = html.fromstring(results.content)
try:
tournament_name = results_tree.xpath(
'//span[@class="tournName"]/text()')[0]
updated = (results_tree.xpath('//span[@class="lastUpdate"]/text()')
[0].replace('Last Updated:', '').strip())
except IndexError:
raise ScrapeError("Tournament info not found.")
self.tournament = Tournament(tournament_name, results.url, updated)
# Get tournament events
try:
event_urls = results_tree.xpath(
'//div[@id="schedule"]/table/tr/td/a[text()="View"]/@href')
except IndexError:
raise ScrapeError("No event schedule found.")
loop = asyncio.new_event_loop()
loop.run_until_complete(self.scrape_events(event_urls))
return self.tournament
def init(request, scope):
tournament = Tournament()
if scope == 'all' or scope == 'matches':
tournament.initialize_matches()
if scope == 'all' or scope == 'teams':
tournament.initialize_teams()
return HttpResponse()
def add_tournament():
add_url = url_for('.add_tournament')
if request.method == 'POST':
file = request.files['file']
filename = file.filename
if not filename:
flash('Додайте файл з турнірними даними', 'isa_warning')
return redirect(url_for('.add_tournament'))
if not allowed_file(filename):
flash('Файл має бути текстовим', 'isa_error')
return redirect(url_for('.add_tournament'))
insert_data = dict(request.form)
insert_data['is_ranked'] = 'is_ranked' in insert_data.keys()
insert_data['date_start'] = request.form.getlist('date_start')[0]
insert_data['date_end'] = request.form.getlist('date_end')[0]
tournament_id = None
try:
tournament_id = Tournament.execute_insert([insert_data])[0]
parser = TournamentParser(file.read(), tournament_id)
parser.run()
except Exception:
flash('Oops!', 'isa_error')
if tournament_id:
pairing_ids = Pairing.select_attrs(
['id'], {'tp.tournament_id': tournament_id})
existing_participant_ids = Participant.select_attrs(
['id'], {'tournament_id': tournament_id})
Pairing.execute_delete([p[0] for p in pairing_ids])
Participant.execute_delete(
[p[0] for p in existing_participant_ids])
Tournament.execute_delete([tournament_id])
return redirect(url_for('.add_tournament'))
return redirect(
url_for('.tournament_info', tournament_id=tournament_id))
cities = City.select_attrs(['id', 'name'])
form = '\n'.join([
'<div class="container">',
f'<form action="{add_url}" enctype="multipart/form-data" method="post">',
render_text_input_row("name", "Назва"),
render_select_row('city_id', "Місто", cities),
render_date_row('date_start', 'Дата початку',
str(datetime.date.today())),
render_date_row('date_end', 'Дата закінчення',
str(datetime.date.today())),
render_text_input_row("pin", "EGF PIN"),
render_checkbox_row('is_ranked', "Рейтинговий"),
render_file_row('file', 'Файл'),
render_submit(),
'</form>',
'</div>',
])
return render_template('add_tournament.html', form=form)
def post(self):
tournament_name = self.request.get("tournament_name")
if Tournament.get_by_key_name(tournament_name):
# TODO error: already exists
return
max_enrollment = int(self.request.get("max_enrollment"))
assert not (max_enrollment < 4 or max_enrollment > 64)
background = self.request.get("background")
seed_by = self.request.get("seed_by")
coach = Coach.get_by_key_name(self.request.get("coach_key_name"))
min_tv = self.request.get("min_tv")
max_tv = self.request.get("max_tv")
min_ma = self.request.get("min_ma")
max_ma = self.request.get("max_ma")
# compute race restrictions
race_restriction = self.request.get("race_restriction")
if race_restriction:
races_allowed = self.request.get_all("races_allowed")
races_allowed = [
db.Key.from_path("Race", race_name) for race_name in races_allowed]
else:
races_allowed = []
tournament = Tournament(
key_name = tournament_name,
owner = coach,
background = background,
max_enrollment = max_enrollment,
seed_by = seed_by,
races_allowed = races_allowed)
def format_tv(tv):
tv = (tv / 10) * 10
return max(0, min(3500, tv))
if min_tv:
tournament.min_tv = int(min_tv)
if max_tv:
tournament.max_tv = int(max_tv)
if min_ma:
tournament.min_ma = int(min_ma)
if max_ma:
tournament.max_ma = int(max_ma)
trophy_pic = self.request.get("trophy_pic")
if trophy_pic:
pic = TournamentPicture.create_from_img(tournament_name, trophy_pic)
pic.put()
tournament.pic = pic
tournament.put()
views.Tournaments.clear()
# I need to give a response or I get an error. Nobody on the internet seems
# to know why. See https://github.com/malsup/form/issues#issue/22.
self.response.out.write("OK")
def test_participants_add_two_count(self):
# add two/more participants, assert the number of participants
num_participants = self.session.query(Participant).count()
character_one = Character(name='Snorlax',
universe='Pokemon',
weight='180',
moves='Rollout, Belly Drum, Heavy Slam, Yawn',
debut='2004',
tier='E',
image_path='Snorlax.png')
character_two = Character(name='Sonic',
universe='Sonic',
weight='95',
moves='Hammer Spin Dash, Burning Spin Dash, Spring Jump, Springing Headbutt',
debut='2013',
tier='A',
image_path='Sonic.png')
tournament_one = Tournament(name='bust2',
sanitized='bust2',
date='April 11th, 2015',
location='CA',
image_path='https://images.smash.gg/images/tournament/1035/image-10e39229043ff962dd367a516b0bc090.png')
tournament_two = Tournament(name='Smash Broski',
sanitized='smash-broski',
date='April 1, 2017',
location='MA',
image_path='path_to_image')
participant_one = Participant(sponsor='C9',
tag='mang0',
main=character_one,
location='California',
tournament=tournament_one)
participant_two = Participant(sponsor='Selfless',
tag='Broseidon',
main=character_two,
location='Russia',
tournament=tournament_two)
self.object_list.append(character_one)
self.object_list.append(character_two)
self.object_list.append(tournament_one)
self.object_list.append(tournament_two)
self.object_list.append(participant_one)
self.object_list.append(participant_two)
self.commit_objects()
self.assertEqual(self.session.query(Participant).count(),
num_participants + 2)
def post(self):
user = tusers.get_current_user()
if user:
#Check if we are modifying a tournament or making a new one
if self.request.get('id'):
new_tournament = ndb.Key('Tournament', int(self.request.get('id'))).get()
else:
new_tournament = Tournament()
new_tournament.name = self.request.get('name')
new_tournament.owner = [user.key]
new_tournament.trackpin = pin_gen()
dates_valid = True
try:
new_tournament.start = datetime.datetime.strptime(self.request.get('start'), '%Y-%m-%d').date()
new_tournament.end = datetime.datetime.strptime(self.request.get('end'), '%Y-%m-%d').date()
except ValueError:
dates_valid = False
if (dates_valid and len(new_tournament.name) > 0):
new_tournament.put()
#Send the user back to the tournaments page
self.redirect('/tournaments')
else:
self.redirect(tusers.create_login_url(self.request.uri))
def create_tournament(request):
# if this is a POST request we need to process the form data
if request.method == "POST":
# create a form instance and populate it with data from the request:
form = TournamentForm(request.POST)
# check whether it"s valid:
if form.is_valid():
tournament = Tournament(name=form.cleaned_data["name"])
form.cleaned_data['url'] = ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(20))
tournament.setup(form.cleaned_data)
tournament.save()
return render(request, "tournament/detail.html", {"tournament": tournament})
else:
form = TournamentForm()
return render(request, "tournament/create.html", {"form": form, "action":reverse("create_tournament")})
def new_tt(self):
""" create new tournament object """
self.tournament_view.new_tournament_name()
name = input()
location = self.tournament_view.new_tournament_location()
date = self.tournament_view.new_tournament_date()
rounds_number = 4
tt_list = ()
pl_list = []
timer = self.tournament_view.new_tournament_timer()
description = self.tournament_view.new_tournament_description()
new_tournament = Tournament(name, location, date, rounds_number,
tt_list, pl_list, timer, description)
self.tournament_table.insert(new_tournament.serialize_tournament())
self.tournament_menu()
def process_players():#This method sets up players in the database so that their scores can be tracked
if request.method == 'POST':
player_1_Name = request.form['player1']
player_2_Name = request.form['player2']
player_3_Name = request.form['player3']
player_4_Name = request.form['player4']
tournament_Name = request.form['tournament_name']
if (player_1_Name and player_2_Name and player_3_Name and player_4_Name) == None or (player_1_Name and player_2_Name and player_3_Name and player_4_Name) == "" or (player_1_Name and player_2_Name and player_3_Name and player_4_Name) == False:
flash('No blank names allowed, please input 4 player names.')
return redirect('/initiate_tournament?p1='+player_1_Name+'&p2='+player_2_Name+'&p3='+player_3_Name+'&p4='+player_4_Name+'&tname='+tournament_Name)
else:#This adds a tournament and players to the database
logged_in_user_id = User.query.filter_by(email=session['user']).first().id
db.session.add(Tournament(logged_in_user_id, tournament_Name))
db.session.commit()
session['tournament_Id'] = Tournament.query.filter_by(name=tournament_Name).first().id
db.session.add(Player(player_1_Name,session['tournament_Id'],logged_in_user_id))#Players are instatiated using player name from template POST request and tournament_ID session variable
db.session.add(Player(player_2_Name,session['tournament_Id'],logged_in_user_id))
db.session.add(Player(player_3_Name,session['tournament_Id'],logged_in_user_id))
db.session.add(Player(player_4_Name,session['tournament_Id'],logged_in_user_id))
db.session.commit()
#After players have been confirmed in the DB, their name is assigned into Session variables
player_1_Id = Player.query.filter_by(name = player_1_Name , owner_id = logged_in_user_id).first().id
player_2_Id = Player.query.filter_by(name = player_2_Name , owner_id = logged_in_user_id).first().id
player_3_Id = Player.query.filter_by(name = player_3_Name , owner_id = logged_in_user_id).first().id
player_4_Id = Player.query.filter_by(name = player_4_Name , owner_id = logged_in_user_id).first().id
session['player_1_Id'] = player_1_Id
session['player_2_Id'] = player_2_Id
session['player_3_Id'] = player_3_Id
session['player_4_Id'] = player_4_Id
return redirect('/score_input')
def get(self):
tournament = Tournament.get(self.request.get("tournament_key"))
if tournament.pic:
self.response.headers['Content-Type'] = "image/png"
self.response.out.write(getattr(tournament.pic, self.request.get("size")))
else:
self.error(404)
def get(self):
user = tusers.get_current_user()
if user:
#Get a list of tournaments that the user owns
owner_q = Tournament.query(Tournament.owner == user.key)
#Get a list of tournaments that the user is attending
attend_q = Attending.query(ancestor=user.key)
#Build a list of tournaments to pass to the view
tournaments = []
for a in attend_q:
tournament = tournament_bean()
tournament.tournament = a.tournament.get()
tournament.role = a.role
tournaments.append(tournament)
template_values = {
'user' : user,
'tournaments' : owner_q,
'attending' : tournaments,
'logout' : tusers.create_logout_url('/'),
}
template = JINJA_ENVIRONMENT.get_template('view/tournaments.html')
self.response.write(template.render(template_values))
else:
self.redirect(tusers.create_login_url(self.request.uri))
def test_participants_add_one(self):
# add a participant
character = Character(name='Snorlax',
universe='Pokemon',
weight='180',
moves='Rollout, Belly Drum, Heavy Slam, Yawn',
debut='2004',
tier='E',
image_path='Snorlax.png')
tournament = Tournament(name='bust2',
sanitized='bust2',
date='April 11th, 2015',
location='CA',
image_path='https://images.smash.gg/images/tournament/1035/image-10e39229043ff962dd367a516b0bc090.png')
participant = Participant(sponsor='C9',
tag='mang0',
main=character,
location='California',
tournament=tournament)
self.object_list.append(character)
self.object_list.append(tournament)
self.object_list.append(participant)
self.commit_objects()
result = self.session.query(Participant).order_by(
Participant.id.desc()).first()
self.assertEqual(result.sponsor, participant.sponsor)
self.assertEqual(result.tag, participant.tag)
self.assertEqual(result.location, participant.location)
self.assertEqual(result.tournament, participant.tournament)
def resolve_schools(parent, info):
schools_info = SQLTournament.get_schools_for_tournament(parent.id)
schools = [
School(tournament_id=school["tournament_id"], name=school["name"])
for school in schools_info
]
return schools
def delete_tournament(tournament_id):
try:
pairing_ids = Pairing.select_attrs(['id'],
{'tp.tournament_id': tournament_id})
existing_participant_ids = Participant.select_attrs(
['id'], {'tournament_id': tournament_id})
Pairing.execute_delete([str(p[0]) for p in pairing_ids])
Participant.execute_delete(
[str(p[0]) for p in existing_participant_ids])
Tournament.execute_delete([str(tournament_id)])
flash('Турнір видалений', 'isa_success')
return redirect(url_for('.tournaments'))
except mysql.connector.Error as err:
flash(err.msg, 'isa_error')
return redirect(
url_for('.tournament_info', tournament_id=tournament_id))
def post(self):
user = users.get_current_user()
if not CheckUserLoggedInAndMaybeReturnStatus(self.response, user):
return
request_dict = self._ParseRequestInfoAndMaybeSetStatus()
if not request_dict:
return
name = request_dict['name']
no_pairs = request_dict['no_pairs']
no_boards = request_dict['no_boards']
player_list = request_dict.get('players')
if not self._CheckValidTournamentInfoAndMaybeSetStatus(
name, no_pairs, no_boards, player_list):
return
tourney = Tournament.CreateAndPersist(
owner_id=user.user_id(),
name=name,
no_pairs=no_pairs,
no_boards=no_boards,
boards=boardgenerator.GenerateBoards(35))
tourney.PutPlayers(player_list, no_pairs)
self.response.set_status(201)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(json.dumps({"id": str(tourney.key.id())}))
def post(self):
user = users.get_current_user()
request_dict = self._ValidateNewTournamentInfoAndMaybeSetStatus(user)
if not request_dict:
return
name = request_dict['name']
no_pairs = request_dict['no_pairs']
no_boards = request_dict['no_boards']
player_list = request_dict.get('players')
allow_score_overwrites = request_dict.get('allow_score_overwrites', False)
tourney = Tournament.CreateAndPersist(owner_id=user.user_id(),
name=name,
no_pairs=no_pairs,
no_boards=no_boards,
boards=boardgenerator.GenerateBoards(35))
tourney.PutPlayers(player_list, 0)
if allow_score_overwrites:
tourney.Unlock()
else:
tourney.MakeLockable()
self.response.set_status(201)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(json.dumps({"id": str(tourney.key.id())}))
def resolve_outstanding_competitors(parent, info, role):
return [
IndividualAward(
side=Side.PL,
ranks=s["ranks"],
student=Student(id=s["id"], name=s["name"]),
) for s in SQLTournament.get_all_witness_awards(parent.id)
]
def get(self):
tournament = Tournament.get(self.request.get("tournament_key"))
if tournament.pic:
self.response.headers['Content-Type'] = "image/png"
self.response.out.write(
getattr(tournament.pic, self.request.get("size")))
else:
self.error(404)
def create_tournament():
name = request.values['tournament-name']
tournament = Tournament(organizer=current_user, name=name)
pair = Pair(tournament=tournament)
for i in range(17):
key = 'captain{}'.format(i)
if key in request.values:
if request.values[key] != '':
id = request.values[key]
cap = Captain.query.get(int(id))
cap.team.total_score = 0
for member in cap.team.members:
member.score = 0
member.assessed = False
db.session.add(member)
cap.tournament = tournament
if len(pair.captains) < 2:
pair.captains.append(cap)
else:
pair = Pair(tournament=tournament)
pair.captains.append(cap)
db.session.add(cap)
db.session.add(pair)
db.session.commit()
for i in range(6):
key = 'judge{}'.format(i)
if key in request.values:
if request.values[key] != '':
id = request.values[key]
judge = Judge.query.get(int(id))
tournament.judges.append(judge)
db.session.add(tournament)
db.session.commit()
number_of_teams = request.values['number-of-teams']
tournament.number_of_teams = number_of_teams
db.session.add(tournament)
db.session.commit()
flash('Tournament has been created successfully!')
return redirect(url_for('index'))
def test_create_and_find_match(g):
p = Player("test player")
p2 = Player("test player 2")
player_dao.create(p)
p.id = 1
player_dao.create(p2)
p2.id = 2
t = Tournament(0,'','T1','type',0)
tournament_dao.create(t)
t.id = 1
match_dao.create([p.id, p2.id], t.id)
retrieved_match = match_dao.find(1)
assert retrieved_match.id == 1
assert retrieved_match.player1.fname == p.fname
assert retrieved_match.player2.fname == p2.fname
def index(pk=0):
signup_form = SignUpForm()
current_tournament = Tournament.query.filter_by(id=pk).first()
if current_tournament is None:
current_tournament = Tournament.query.first()
if current_tournament is None:
current_tournament = Tournament(name='Initial')
judges = Judge.query.all()
captains = Captain.query.all()
tournaments = Tournament.query.all()
round1 = []
round2 = []
round3 = []
round4 = []
round5 = []
for pair in current_tournament.pairs:
if pair.round == 1:
round1.append(pair)
elif pair.round == 2:
round2.append(pair)
elif pair.round == 3:
round3.append(pair)
elif pair.round == 4:
round4.append(pair)
elif pair.round == 5:
round5.append(pair)
current_captains = []
caps = dict()
if current_tournament:
current_captains = current_tournament.captains.all()
i = 1
for captain in current_captains:
key = "captain{}".format(i)
caps[key] = captain
i += 1
print(current_captains)
print(caps)
return render_template('index.html',
signup_form=signup_form,
judges=judges,
captains=captains,
tournaments=tournaments,
current_tournament=current_tournament,
caps=caps,
round1=round1,
round2=round2,
round3=round3,
round4=round4,
round5=round5,
positions=positions)
def get_tournaments():
"""
Parses data feed of Wizard's MTGO decklist site[1].
Returns a list of tournament objects or an empty list if an error occurs.
[1] http://www.wizards.com/magic/Digital/MagicOnline.aspx?x=mtg/digital/magiconline/whatshappening
"""
try:
logger.info('Retrieving tournament feed.')
content = requests.get(TOURNAMENT_INFO_URL).content
items = json.loads(content)
logger.info('%i tournaments were found' % len(items))
with open(PROCESSED_TOURNAMENT_FILE, 'r+') as processed_tournaments_file:
processed_tournaments = processed_tournaments_file.read().split(',')
if processed_tournaments == ['']:
processed_tournaments = []
results = []
for item in items:
if item['Hyperlink'] in processed_tournaments:
logger.info('Skipping tournament %s' % item['Hyperlink'])
continue
tournament = Tournament()
tournament.hyperlink_id = item['Hyperlink']
tournament.tournament_format = item['Name']
tournament.tournament_date = item['Date']
try:
logger.info('Processing tournament %s' % tournament.hyperlink_id)
for deck in tournament.decks:
deck.save()
processed_tournaments.append(tournament.hyperlink_id)
results.append(tournament)
except:
logger.error('Error downloading tournament-specific information for tournament %s.' % tournament.hyperlink_id)
processed_tournaments_file.truncate()
processed_tournaments_file.write(','.join(processed_tournaments))
return results
except:
print sys.exc_info()
logger.error('An error occurred while downloading tournament information.')
return []
def __call__(self):
if len(self.db.all_tournaments_in_progress()) > 0:
self.tournament_view.display_error_tournament_active()
else:
tournament_infos = self.tournament_view.get_info()
tournament = Tournament(name=tournament_infos[0],
location=tournament_infos[1],
number_of_turns=int(tournament_infos[2]),
description=tournament_infos[3],
time_control=tournament_infos[4])
tournament.save_in_db()
n = 1
while n < 9:
self.add_a_player(tournament=tournament)
self.tournament_view.incremented_player_number(n)
n += 1
return HomeMenuController()
def tournament_getting_players():
tour_query = db_session.query(Tournament)
tournaments = tour_query.all()
curr_tour = None
if tournaments != None:
for tournament in tournaments:
if tournament.semi_final == "":
curr_tour = tournament
break
else:
if tournament.winner == None:
if tournament.final != "":
if current_user.id in ast.literal_eval(
tournament.final):
return abort(409)
elif tournament.semi_final != "":
if current_user.id in ast.literal_eval(
tournament.semi_final):
return abort(409)
elif tournament.quarter_final != "":
if current_user.id in ast.literal_eval(
tournament.quarter_final):
return abort(409)
if tournaments == None or curr_tour == None:
tournament = Tournament()
db_session.add(tournament)
waiting = []
if tournament.waiting_users != "":
waiting = ast.literal_eval(tournament.waiting_users)
if len(waiting) > 7:
return abort(409)
current_user.is_waiting = 1
if tournament.quarter_final != "":
return abort(409)
waiting.append(current_user.id)
tournament.waiting_users = str(waiting)
db_session.commit()
return "OK"
def resolve_teams(parent, info):
teams = SQLTournament.get_teams_for_tournament(parent.id)
return [
Team(
tournament_id=parent.id,
num=team["num"],
name=team["name"],
school_name=team["school_name"],
) for team in teams
]
def init_data(self):
# upload tournaments and teams from DB
for l_id in self.FOOTBALL_COMPETITION_IDS:
tournament = Tournament.get(l_id, self.FIND_TOURN_BY)
if not tournament:
self.leagues_list[l_id] = None
else:
t_id = str(tournament['_id'])
self.leagues_list[l_id] = League(t_id, Team.find(t_id))
def test_tournaments_add_two_count(self):
# add two tournaments, assert there are two tournaments
num_tournaments = self.session.query(Tournament).count()
self.object_list.append(Tournament(name='bust2',
sanitized='bust2',
date='April 11th, 2015',
location='CA',
image_path='https://images.smash.gg/images/tournament/1035/image-10e39229043ff962dd367a516b0bc090.png'))
self.object_list.append(Tournament(name='Smash Broski',
sanitized='smash-broski',
date='April 1, 2017',
location='MA',
image_path='path_to_image'))
self.commit_objects()
self.assertEqual(self.session.query(
Tournament).count(), num_tournaments + 2)
def put(self):
''' Creates a new tournament with all the preexisting hands based on the
the parameters specified in the request.
'''
user = users.get_current_user()
new_tournament_dict = self._ValidateNewTournamentInfoAndMaybeSetStatus(user)
if not new_tournament_dict:
return
name = new_tournament_dict['name']
no_pairs = new_tournament_dict['no_pairs']
no_boards = new_tournament_dict['no_boards']
player_list = new_tournament_dict.get('players')
allow_score_overwrites = new_tournament_dict.get('allow_score_overwrites',
False)
tourney = Tournament.CreateAndPersist(owner_id=user.user_id(),
name = name,
no_pairs=no_pairs,
no_boards=no_boards,
boards=boardgenerator.GenerateBoards(35))
tourney.PutPlayers(player_list, 0)
if allow_score_overwrites:
tourney.Unlock()
else:
tourney.MakeLockable()
hands_list = self._ParseHandsFromRequestAndMaybeSetStatus()
if hands_list is None:
return
for hand in hands_list:
board_no = hand.get("board_no")
ns_pair = hand.get("ns_pair")
ew_pair = hand.get("ew_pair")
if not CheckValidHandPlayersCombinationAndMaybeSetStatus(
self.response, tourney, int(board_no), int(ns_pair), int(ew_pair)):
return
calls = hand.setdefault("calls", {})
ns_score = hand.get("ns_score")
ew_score = hand.get("ew_score")
notes = hand.get("notes")
if not ValidateHandResultMaybeSetStatus(self.response, int(board_no),
int(ns_pair), int(ew_pair),
ns_score, ew_score, calls):
return
tourney.PutHandScore(int(board_no), int(ns_pair), int(ew_pair), calls,
ns_score, ew_score, notes, 0)
self.response.set_status(201)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(json.dumps({"id": str(tourney.key.id())}))
def init_data(self):
for t_name in self.config['tournaments_list']:
tournament = Tournament.get(t_name, self.FIND_TOURN_BY)
infogol_id = self.config['tournaments_list'][t_name]
if not tournament:
self.leagues_list[t_name] = None
else:
t_id = str(tournament['_id'])
self.leagues_list[t_name] = League(t_id, Team.find(t_id),
Game.find_all(t_id),
infogol_id)
def post(self):
user = users.get_current_user()
coach = Coach.all().filter("user ="******"tournament_key"))
memberships = [m for m in TournamentMembership.all().ancestor(tournament) if
m.team.coach.key() == coach.key()]
membership = memberships[0]
membership.delete()
views.Tournaments.clear()
def mutate(parent, info, tournament_id, matchups):
existing_rounds = SQLTournament.get_all_rounds(tournament_id)
current_round = len(existing_rounds) + 1
for matchup in matchups:
SQLMatchup.add_matchup(
tournament_id,
round_num=current_round,
pl=matchup["pl"],
defense=matchup["defense"],
)
return Round(round_num=current_round, tournament_id=tournament_id)
def get(self):
tournament = Tournament.get(self.request.get("key"))
member_count = TournamentMembership.all().ancestor(tournament).count()
html = ["<input type='hidden' name='tournament_key' value='%s' />" % tournament.key()]
html.append("<p>Provide each team with a unique seed ranging from 1 to %s:</p>"
% member_count)
for member in TournamentMembership.all().ancestor(tournament):
html.append("%s: <input type='text' name='seed_%s'><br />" % (
member.team.key().name(), member.key()))
self.response.out.write("\n".join(html))
def get(self):
user = users.get_current_user()
if not CheckUserLoggedInAndMaybeReturnStatus(self.response, user):
return
# TODO: Implement paging if ever needed.
tourneys = Tournament._query(Tournament.owner_id ==
user.user_id()).fetch(projection=[Tournament.name])
tourney_list = [{"id": str(t.key.id()), "name": t.name} for t in tourneys]
self.response.set_status(200)
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(json.dumps({"tournaments": tourney_list}, indent=2))
def add_a_player(self, tournament: Tournament):
"""
Create a player instance and save data in the table "players" from the database
"""
player_infos = self.player_view.check_if_player_exists()
player_first_name = player_infos[0]
player_last_name = player_infos[1]
if (player_first_name, player_last_name) not in [
(i.first_name, i.last_name) for i in self.players
]:
more_infos = self.player_view.ask_more_infos()
Player(first_name=player_first_name,
last_name=player_last_name,
birth=more_infos[0],
gender=more_infos[1]).save_in_db()
for player in self.db.load_player_data():
if player.first_name == player_first_name and player.last_name == player_last_name:
player = player.get_document_from_instance()
tournament.add_player_in_tournament(player)
def test_standings(g):
p = Player("test player")
p2 = Player("test player 2")
p3 = Player("test player 3")
player_dao.create(p)
p.id = 1
player_dao.create(p2)
p2.id = 2
player_dao.create(p3)
p3.id = 3
t = Tournament(0,'','T1','type',0)
tournament_dao.create(t)
t.id = 1
match_dao.create([p.id, p2.id], t.id)
match_dao.create([p.id, p3.id], t.id)
match_dao.create([p3.id, p2.id], t.id)
match = Match(player1=p,player2=p2,id=1)
match.score1 = 19
match.score2 = 21
match2 = Match(player1=p,player2=p3,id=2)
match2.score1 = 17
match2.score2 = 21
match3 = Match(player1=p3,player2=p2,id=3)
match3.score1 = 23
match3.score2 = 21
match_dao.update(match)
match_dao.update(match2)
match_dao.update(match3)
standings = standings_dao.find(t.id)
assert standings[0].name == p.fname
assert standings[0].win == 0
assert standings[0].loss == 2
assert standings[1].name == p2.fname
assert standings[1].win == 1
assert standings[1].loss == 1
assert standings[2].name == p3.fname
assert standings[2].win == 2
assert standings[2].loss == 0
def create_tournament(payload):
data = request.json
# Prepare game
game = Game.query.filter(Game.id == data['gameId']).first()
if not game:
game = Game.query.filter(Game.name.ilike(data['gameName'].strip())).first()
if not game:
game = Game(name=data['gameName'])
db.session.add(game)
db.session.flush()
tournament = Tournament(name=data)
# Generate the UUID
uuid_len = 6
tries = 0
max_tries = 10
tournament_found = True
uuid = ''
while tournament_found:
if tries >= max_tries:
tries = 0
uuid_len += 1
tries += 1
uuid = generate_uuid(uuid_len)
tournament_found = db.session.query(Tournament).filter(tournament.uuid == uuid).first()
tournament.uuid = uuid
tournament.name = data['name']
tournament.max_participants = data['maxParticipants']
if 'startDate' in data:
tournament.start_date = data['startDate']
if 'startDateTz' in data:
tournament.start_date_tz = data['startDateTz']
tournament.game_id = game.id
user = auth.get_logged_user()
tournament.creator_id = user.id
db.session.add(tournament)
db.session.flush()
db.session.commit()
return jsonify(tournament.long()), 201
def test_tournaments_add_two_validate_data(self):
# add two tournaments, assertEqual for name, date, location, entrants,
# picture
num_tournaments = self.session.query(Tournament).count()
tournaments = []
tournament_one = Tournament(name='bust2',
sanitized='bust2',
date='April 11th, 2015',
location='CA',
image_path='https://images.smash.gg/images/tournament/1035/image-10e39229043ff962dd367a516b0bc090.png')
tournament_two = Tournament(name='Smash Broski',
sanitized='smash-broski',
date='April 1, 2017',
location='MA',
image_path='path_to_image')
self.object_list.append(tournament_one)
self.object_list.append(tournament_two)
tournaments.append(tournament_two)
tournaments.append(tournament_one)
self.commit_objects()
for i in range(0, len(tournaments)):
result = self.session.query(Tournament).order_by(
Tournament.id.desc()).first()
self.assertEqual(result.name, tournaments[i].name)
self.assertEqual(result.sanitized, tournaments[i].sanitized)
self.assertEqual(result.date, tournaments[i].date)
self.assertEqual(result.location, tournaments[i].location)
self.assertEqual(result.image_path, tournaments[i].image_path)
# Removing the element from the table
self.session.delete(result)
self.session.commit()
self.object_list.remove(result)
def edit_tournament(tournament_id):
edit_url = url_for('.edit_tournament', tournament_id=tournament_id)
if request.method == 'POST':
update_data = dict(request.form)
update_data['is_ranked'] = 'is_ranked' in update_data.keys()
update_data['date_start'] = request.form.getlist('date_start')[0]
update_data['date_end'] = request.form.getlist('date_end')[0]
try:
Tournament.execute_update(tournament_id, update_data)
flash('Дані турніру оновлені', 'isa_success')
return redirect(
url_for('.tournament_info', tournament_id=tournament_id))
except mysql.connector.Error as err:
flash(err.msg, 'isa_error')
return redirect(edit_url)
tournament = Tournament.execute_select({'id': tournament_id})[0]
cities = City.select_attrs(['id', 'name'])
form = '\n'.join([
'<div class="container">',
f'<form action="{edit_url}" method="post">',
render_text_input_row("name", "Назва", tournament.name),
render_select_row('city_id', "Місто", cities, tournament.city.id),
render_date_row('date_start', 'Дата початку', tournament.date_start),
render_date_row('date_end', 'Дата закінчення', tournament.date_end),
render_text_input_row("pin", "EGF PIN", tournament.pin),
render_checkbox_row('is_ranked', "Рейтинговий", tournament.is_ranked),
render_submit(),
'</form>',
'</div>',
])
return render_template('edit_tournament.html',
tournament=tournament,
form=form)
def post(self):
user = users.get_current_user()
coach = Coach.all().filter("user ="******"tournament_key"))
memberships = [
m for m in TournamentMembership.all().ancestor(tournament)
if m.team.coach.key() == coach.key()
]
membership = memberships[0]
membership.delete()
views.Tournaments.clear()
def load_tt(self):
""" load a tournament from a json """
tt = []
self.menu.new_tournament_name()
Tournament_name = input()
tournaments = self.tournamentcontroller.tournament_table.search(
self.tournamentcontroller.tournamentquery.Tournament_name ==
f"{Tournament_name}")
if len(tournaments) == 1:
for tournament in tournaments:
tt.append(Tournament.deserialize_tournament(tournament))
return tt[0]
else:
self.start_menu()
def post(self):
request_data = json.loads(self.request.body)
logging.info(request_data)
player = current_user_player()
team_key = player.team
tournament = Tournament.get_by_id(int(request_data['tournament_id']))
if team_key in tournament.participants:
error_400(self.response, "ERROR_ALREADY_IN_TOURNAMENT", "Your team has already joined the tournament '%s'" % tournament.name)
return
tournament.participants.append(team_key)
tournament.put()
set_json_response(self.response, {'code': "OK"})
def post(self):
tournament = Tournament.get(self.request.get("tournament_key"))
member_count = TournamentMembership.all().ancestor(tournament).count()
for arg in self.request.arguments():
if arg.startswith("seed_"):
member_key = arg.split("_")[1]
member = TournamentMembership.get(member_key)
seed = int(self.request.get(arg)) - 1
assert seed >= 0 and seed < member_count
member.seed = seed
member.put()
tournament.schedule()
views.Tournaments.clear()
def post(self):
tournament = Tournament.get(self.request.get("tournament_key"))
team = Team.get(self.request.get("team_key"))
member_count = TournamentMembership.all().ancestor(tournament).count()
if member_count < tournament.max_enrollment:
TournamentMembership(parent=tournament, team=team, active=True).put()
#Unretire team if retired.
if team.retired:
misc.unretire_team(team)
if (member_count + 1 == tournament.max_enrollment and
tournament.seed_by != "Custom"):
tournament.schedule()
views.Tournaments.clear()
def get(self):
user = tusers.get_current_user()
if user:
#Get a list of tournaments that the user owns
owner_q = Tournament.query(Tournament.owner == user.key)
#Tournaments that the user has registered for
reg_q = RegisteredEntity.query(RegisteredEntity.user == user.key)
attending = reg_q.map(tournament_for_registration)
logging.info(attending)
template_values = {
'user' : user,
'tournaments' : owner_q,
'logout' : tusers.create_logout_url('/'),
'attending' : attending
}
template = JINJA_ENVIRONMENT.get_template('view/tournaments.html')
self.response.write(template.render(template_values))
else:
self.redirect(tusers.create_login_url(self.request.uri))
def dress_new(request):
if request.method=='POST':
try:
id = int(request.session[new_dress_key])
dress = Tournament.objects.get(pk=id)
except:
raise Http404
form = DressForm(count=len(request.FILES), data=request.POST, files=request.FILES)
if form.is_valid():
dress = form.save(request.FILES, dress)
request.session[new_dress_key] = None
return redirect(dress)
else:
form.save_photos(dress)
else:
if new_dress_key in request.session.keys():
try:
id = int(request.session[new_dress_key])
dress = Tournament.objects.get(pk=id)
if not dress.confirmed:
dress.delete()
except:
pass
dress = Tournament()
dress.confirmed = False
dress.date = datetime.datetime.now()
dress.access_key = ''.join(random.choice(string.letters) for i in xrange(DressForm.ACCESS_KEY_LENGTH))
dress.save()
request.session[new_dress_key] = dress.id
form = DressForm()
if settings.DEBUG:
form.load_test_data()
return render_to_response('dress_edit.html', {'form':form, 'is_new':True, 'dress': dress}, context_instance=RequestContext(request))
def get(self):
# check for a cached version
#--------------------------------------------------------------------#
if self.emit(self.response.out):
return
# not cached or evicted from cache; regenerate
#--------------------------------------------------------------------#
user = users.get_current_user()
coach = None
if user:
coach = Coach.all().filter("user ="******"<img src='get_trophy?size=thumb&tournament_key=%s' />" % tournament.key()
return ""
def name_getter(tournament):
return "<a rel='tournaments' href='%s'>%s</a>" % (
tournament.get_box_href(), tournament.key().name())
def date_getter(tournament):
return tournament.created.date()
def organizer_getter(tournament):
return tournament.owner.key().name()
def enrollment_getter(tournament):
return "%s/%s" % (
TournamentMembership.all().ancestor(tournament).count(),
tournament.max_enrollment)
def final_enrollment_getter(tournament):
return TournamentMembership.all().ancestor(tournament).count()
def winner_getter(tournament):
return "<a rel='winners' href='%s'>%s</a> (%s)" % (
tournament.winning_team.get_box_href(),
tournament.winning_team.key().name(),
tournament.winning_team.coach.key().name())
def tv_getter(tournament):
if tournament.min_tv and tournament.max_tv:
return "%s - %s" % (tournament.min_tv, tournament.max_tv)
elif tournament.min_tv:
return "≥ %s" % tournament.min_tv
elif tournament.max_tv:
return "≤ %s" % tournament.max_tv
else:
return "Any"
def ma_getter(tournament):
if tournament.min_ma != None and tournament.max_ma != None:
return "%s - %s" % (tournament.min_ma, tournament.max_ma)
elif tournament.min_ma != None:
return "≥ %s" % tournament.min_ma
elif tournament.max_ma != None:
return "≤ %s" % tournament.max_ma
else:
return "Any"
def races_getter(tournament):
if tournament.races_allowed:
return "Restricted"
else:
return "Any"
tournaments = {}
for tournament in Tournament.all():
if tournament.winning_team:
tournaments.setdefault("Completed", []).append(tournament)
elif tournament.started:
tournaments.setdefault("In Progress", []).append(tournament)
else:
tournaments.setdefault("Open", []).append(tournament)
tables = [
("Open", Table(
columns = [
Column("", "Trophy Image", trophy_getter,
center=True),
Column("Name", "Tournament name", name_getter),
Column("Created", "Creation date", date_getter),
Column("Organizer", "Tournament organizer", organizer_getter),
Column("Enrolled", "Enrollment count", enrollment_getter),
Column("TV", "TV range", tv_getter),
Column("Matches Played", "Matches played range", ma_getter),
Column("Races", "Races allowed", races_getter),
Column("Seed By", "Teams are seeded by", attrgetter("seed_by")),
],
query = tournaments.get("Open", []),
cls = "tablesorter tournaments_table",
)),
("In Progress", Table(
columns = [
Column("", "Trophy Image", trophy_getter,
center=True),
Column("Name", "Tournament name", name_getter),
Column("Created", "Creation date", date_getter),
Column("Organizer", "Tournament organizer", organizer_getter),
Column("Enrolled", "Final enrollment count", final_enrollment_getter),
Column("TV", "TV range", tv_getter),
Column("Races", "Races allowed", races_getter),
],
query = tournaments.get("In Progress", []),
cls = "tablesorter tournaments_table",
)),
("Completed", Table(
columns = [
Column("", "Trophy Image", trophy_getter,
center=True),
Column("Name", "Tournament name", name_getter),
Column("Created", "Creation date", date_getter),
Column("Organizer", "Tournament organizer", organizer_getter),
Column("Winner", "Tournament winner", winner_getter),
Column("Enrolled", "Final enrollment count", final_enrollment_getter),
Column("TV", "TV range", tv_getter),
Column("Races", "Races allowed", races_getter),
],
query = tournaments.get("Completed", []),
cls = "tablesorter tournaments_table",
))]
# render and update
#--------------------------------------------------------------------#
tournaments = misc.render('tournaments.html', locals())
self.update(tournaments)
self.response.out.write(tournaments)
def post(self):
tournament = Tournament.get(self.request.get("tournament_key"))
tournament.schedule()
views.Tournaments.clear()
def get(self):
set_json_response(self.response, [tournament.get_data() for tournament in Tournament.query()])
