def login(): errors = {} FORM_ARGS = { 'email': FORM_USER_VALID['email'], 'password': FORM_USER_VALID['password'], } auth_token = None if request.method == 'POST': print("POST") try: parsed_args = parser.parse(FORM_ARGS, location="form") pprint(parsed_args) auth_token = app.action.user.user_get_auth_token( app_cls.service, parsed_args) #resp.set_cookie('auth_token', auth_token) print(f"--> auth_token {auth_token}") # FIXME: register auth_token cookie # FIXME: redirect except DataError as e: errors = e.args[0]['form'] print("ERROR", errors) except app.action.user.ErrWrongPassword as e: print("ERROR", "wrong password") errors = {"user": ["Wrong password or user does not exists."]} except app.action.user.ErrNotVerified as e: print("ERROR", "not verified") errors = {"user": ["User not verified, please check your email."]} resp = make_response(render_template('login.html', errors=errors)) if auth_token: resp = make_response(redirect('/')) resp.set_cookie('auth_token', auth_token) return resp
def current_user(): try: print("[AUTH]") auth_token = request.cookies.get('auth_token') return app.action.user.user_instance_from_token( app_cls, auth_token) except: return None
def search(): query = request.args.get('query') print("QUERY", query) from app.models import Tournament obj = Tournament.query obj = obj.filter(Tournament.title.like('%' + query + '%')) obj = obj.order_by(Tournament.title).all() return render_template('search.html', query=query, tournaments=obj)
def test_user_created(self): user_1 = { "email": '*****@*****.**', "password": '******', "name": "Test 1" } user_2 = { "email": '*****@*****.**', "password": '******', "name": "Test 2" } app.action.user.user_create(self.service, user_1) app.action.user.user_create(self.service, user_2) v1 = 0 print("") for user in User.query.all(): print(f"---> {user} {user.date_created}") print(f"\t{user.password_hash}") print(f"\tverified={user.verified} token={user.recovery}") self.assertEqual(user.verified, False) v1 += 1 self.assertEqual(v1, 2)
def signup(): errors = {} successes = {} FORM_ARGS = { 'name': FORM_USER_VALID['name'], 'email': FORM_USER_VALID['email'], 'password': FORM_USER_VALID['password'], } if request.method == 'POST': print("POST") try: parsed_args = parser.parse(FORM_ARGS, location="form") pprint(parsed_args) user = app.action.user.user_create(app_cls.service, parsed_args) url = send_message_verify(user.email, user.recovery) print(user.recovery) successes = { "user": [ f"We've sent you an email to {user.email} to verify your account. (debug: {url})" ] } except DataError as e: errors = e.args[0]['form'] print("ERROR", errors) except app.action.user.ErrDuplicate as e: print("ERROR", "duplicate") errors = {"user": ["This user already exists (with this email)."]} return render_template('signup.html', errors=errors, successes=successes)
def tournament_join(s, data, tournament, user): if tournament.ladder: print("LADDER!!!!") return False already_joined = (Tier.query.filter(Tier.user_id == user.id).filter( Tier.tournament_id == tournament.id).first()) if already_joined is not None: raise ErrAlreadyJoined() tier = Tier(user_id=user.id, tournament_id=tournament.id, license=data['license'], rating=data['rating']) tournament.tiers.append(tier) s.db.session.commit()
def get_js_results(s, tournament): if tournament.get_ladder()['results'] is None: return str([]) # print(tournament.get_ladder()['results']) results = [] for layer in tournament.get_ladder()['results']: layer_results = [] for match_id in layer: score = [None, None] print(match_id) match = (Match.query.filter(Match.match_id == match_id).filter( Match.tournament_id == tournament.id).first()) # FIXME ----------------------------------------------------- # jak to bedzie????????????????????????????????????????????? if match.results: score = list(map(int, match.results.split("@"))) layer_results.append(score) results.append(layer_results) return str(results).replace("None", "null")
def tournament_close(idx): # FIXME: check if owner? from app.models import Tournament tournament = (Tournament.query.filter(Tournament.id == idx).first()) auth_token = request.cookies.get('auth_token') user = app.action.user.user_instance_from_token(app_cls, auth_token) if user.id != tournament.owner_id: print("NOT OWNER!") return redirect(f'/tournament_display/{tournament.id}') app.action.tournament.tournament_close(app_cls.service, tournament, user, force=True) return redirect(f'/tournament_display/{tournament.id}')
def test_user_auth_token(self): self.test_user_created() email = "*****@*****.**" with self.assertRaises(app.action.user.ErrWrongPassword): app.action.user.user_get_auth_token(self.service, { "email": email, "password": "******" }) # FIXME: now you can't do this! auth_token = app.action.user.user_get_auth_token( self.service, { "email": email, "password": "******" }) with self.assertRaises(app.action.user.ErrAuthNotExists): app.action.user.user_instance_from_token(self.service, auth_token + "x") with self.assertRaises(app.action.user.ErrNotVerified): app.action.user.user_instance_from_token(self.service, auth_token) user = (User.query.filter(User.email == email).first()) with self.assertRaises(app.action.user.ErrWrongRecovery): app.action.user.user_try_verify(self.service, { "email": email, "recovery": user.recovery + "123" }) app.action.user.user_try_verify(self.service, { "email": email, "recovery": user.recovery }) print(f"\nauth_token ----> {auth_token}") holder = app.action.user.user_instance_from_token( self.service, auth_token) self.assertEqual(holder.email, email)
def _create_match(tournament_id, match_id, next_match_id, flag=0): print("======= MATCH ========") print(f"tournament_id = {tournament_id}") print(f"match_id = {match_id} --> {next_match_id}") print(f"flag = {flag}") match = Match( match_id=match_id, tournament_id=tournament_id, next_match_id=next_match_id, flag=flag, ) """ user_id_1 = db.Column(db.Integer, db.ForeignKey('user.id')) user_id_2 = db.Column(db.Integer, db.ForeignKey('user.id')) results = db.Column(db.Text) results_by_user_id_1 = db.Column(db.Text) results_by_user_id_2 = db.Column(db.Text) """ print("======================") return match
def forget_code(code): errors = {} successes = {} args = base64.b64decode(code.encode('utf-8')).decode('utf-8') email, recovery = args.split("/") print(f"|{email}|, |{recovery}|") FORM_ARGS = { 'password': FORM_USER_VALID['password'], } if request.method == 'POST': try: parsed_args = parser.parse(FORM_ARGS, location="form") pprint(parsed_args) app.action.user.user_try_forget( app_cls.service, { "email": email, "recovery": recovery, "password": parsed_args["password"] }) successes = {"user": [f"Account for {email} is now active."]} except app.action.user.ErrWrongRecovery as e: print("ERROR", "wrong recovery") errors = {"user": [f"Wrong recovery code for {email}."]} except app.action.user.ErrTimeout as e: print("ERROR", "timeout") errors = {"user": [f"Timeout (more than 24h) for {email}."]} return render_template('forget_code.html', email=email, errors=errors, successes=successes)
def forget(): errors = {} successes = {} FORM_ARGS = { 'email': FORM_USER_VALID['email'], } if request.method == 'POST': try: parsed_args = parser.parse(FORM_ARGS, location="form") pprint(parsed_args) user = app.action.user.user_new_recovery(app_cls.service, parsed_args) url = send_message_forget(user.email, user.recovery) successes = { "user": [ f"We've sent you an email to {user.email} to recover your account. (debug: {url})" ] } except DataError as e: errors = e.args[0]['form'] print("ERROR", errors) except Exception as e: print("HACKER/DDOS?", e) return render_template('forget.html', errors=errors, successes=successes)
def tournament_unjoin(s, tournament, user): if tournament.ladder: print("LADDER!!!!") return False already_joined = (Tier.query.filter(Tier.user_id == user.id).filter( Tier.tournament_id == tournament.id).delete()) if already_joined is not None: print("UNJOINED!") s.db.session.commit() else: print("NO NEED")
def tournament_edit(idx): errors = {} successes = {} FORM_ARGS = { 'title': FORM_TOURNAMENT_VALID['title'], 'max_users': FORM_TOURNAMENT_VALID['max_users'], 'location': FORM_TOURNAMENT_VALID['location'], 'readme': FORM_TOURNAMENT_VALID['readme'], 'date_start': FORM_TOURNAMENT_VALID['date_start'], 'date_deadline': FORM_TOURNAMENT_VALID['date_deadline'], } from app.models import Tournament tournament = (Tournament.query.filter(Tournament.id == idx).first()) parsed_args = tournament.__dict__ # check if author is editing auth_token = request.cookies.get('auth_token') user = app.action.user.user_instance_from_token(app_cls, auth_token) if user.id != tournament.owner_id: return redirect(f"/tournament_display/{idx}") # if posted -> edit if request.method == 'POST': try: parsed_args = parser.parse(FORM_ARGS, location="form") parsed_args['user'] = user pprint(parsed_args) cur_date = datetime.datetime.utcnow() if parsed_args['date_deadline'] > parsed_args['date_start']: raise ErrFormDate if parsed_args['date_deadline'] < cur_date: raise ErrFormDate tournament = app.action.tournament.tournament_edit( app_cls.service, parsed_args, tournament) successes = {"tournament": [f"The event was edited."]} except DataError as e: errors = e.args[0]['form'] print("ERROR", errors) except app.action.tournament.ErrDuplicate as e: print("ERROR", "duplicate") errors = { "tournament": ["This event already exists (with this title)."] } except ErrFormDate as e: print("ERROR", "date") errors = { "tournament": [ "Wrong datetime span (should be: current <= deadline <= start)." ] } return render_template('tournament_edit.html', tournament=tournament, errors=errors, successes=successes, parsed_args=parsed_args)
def tournament_new(): errors = {} successes = {} FORM_ARGS = { 'title': FORM_TOURNAMENT_VALID['title'], 'max_users': FORM_TOURNAMENT_VALID['max_users'], 'location': FORM_TOURNAMENT_VALID['location'], 'readme': FORM_TOURNAMENT_VALID['readme'], 'date_start': FORM_TOURNAMENT_VALID['date_start'], 'date_deadline': FORM_TOURNAMENT_VALID['date_deadline'], } parsed_args = request.form.to_dict(flat=True) # print(request.form.to_dict(flat=True)) if request.method == 'POST': try: auth_token = request.cookies.get('auth_token') user = app.action.user.user_instance_from_token( app_cls, auth_token) parsed_args = parser.parse(FORM_ARGS, location="form") parsed_args['user'] = user pprint(parsed_args) cur_date = datetime.datetime.utcnow() if parsed_args['date_deadline'] > parsed_args['date_start']: raise ErrFormDate if parsed_args['date_deadline'] < cur_date: raise ErrFormDate tournament = app.action.tournament.tournament_create( app_cls.service, parsed_args) successes = {"tournament": [f"The event was created."]} except DataError as e: errors = e.args[0]['form'] print("ERROR", errors) except app.action.tournament.ErrDuplicate as e: print("ERROR", "duplicate") errors = { "tournament": ["This event already exists (with this title)."] } except ErrFormDate as e: print("ERROR", "date") errors = { "tournament": [ "Wrong datetime span (should be: current <= deadline <= start)." ] } return render_template('tournament_new.html', errors=errors, successes=successes, parsed_args=parsed_args)
def verify(code): errors = {} successes = {} args = base64.b64decode(code.encode('utf-8')).decode('utf-8') email, recovery = args.split("/") print(f"|{email}|, |{recovery}|") try: app.action.user.user_try_verify(app_cls.service, { "email": email, "recovery": recovery }) successes = {"user": [f"Account for {email} is now active."]} except app.action.user.ErrWrongRecovery as e: print("ERROR", "wrong recovery") errors = {"user": [f"Wrong recovery code for {email}."]} except app.action.user.ErrTimeout as e: print("ERROR", "timeout") errors = {"user": [f"Timeout (more than 24h) for {email}."]} return render_template('verify.html', errors=errors, successes=successes)
def tournament_join(idx): errors = {} successes = {} parsed_args = {} FORM_ARGS = { 'license': FORM_TOURNAMENT_VALID['license'], 'rating': FORM_TOURNAMENT_VALID['rating'], } from app.models import Tournament tournament = (Tournament.query.filter(Tournament.id == idx).first()) auth_token = request.cookies.get('auth_token') user = app.action.user.user_instance_from_token(app_cls, auth_token) if request.method == 'POST': try: parsed_args = parser.parse(FORM_ARGS, location="form") parsed_args['user'] = user pprint(parsed_args) cur_date = datetime.datetime.utcnow() if tournament.date_deadline < cur_date: raise ErrFormDate app.action.tournament.tournament_join(app_cls.service, parsed_args, tournament, user) successes = {"tournament": [f"User joined the list."]} except DataError as e: errors = e.args[0]['form'] print("ERROR", errors) except ErrFormDate as e: print("ERROR", "date") errors = {"tournament": ["Deadline passed."]} except app.action.tournament.ErrAlreadyJoined as e: print("ERROR", "already") errors = {"tournament": ["User already on the list."]} return render_template('tournament_join.html', tournament=tournament, errors=errors, successes=successes, parsed_args=parsed_args)
def tournament_create(s, data): try: user = data['user'] print(user) print(s) tournament = Tournament( title=data['title'], date_start=data['date_start'], date_deadline=data['date_deadline'], location=data['location'], max_users=data['max_users'], readme=data['readme'], owner_id=user.id, ) s.db.session.add(tournament) s.db.session.commit() except Exception as e: print(str(e)) if "UNIQUE constraint failed" in str(e): raise ErrDuplicate() raise ErrFatal() return tournament
print("[TOURNAMENT]") import math import random import datetime from app.models import Tournament, Tier, Match from pprint import pprint from app.log import print class ErrFatal(Exception): pass class ErrDuplicate(Exception): pass class ErrAlreadyJoined(Exception): pass # FIXME: remove user from data['user'] def tournament_create(s, data): try: user = data['user'] print(user) print(s) tournament = Tournament( title=data['title'],
def tournament_close(s, tournament, user, force=False): if force is False and tournament.ladder is not None: return False tiers = tournament.tiers.limit(tournament.max_users).all() # FIXME: order users by rating def compare(x, y): return x.rating - y.rating from functools import cmp_to_key tiers = sorted(tiers, key=cmp_to_key(compare), reverse=True) teams = [] results = [] max_users = tournament.max_users if max_users <= 1: tree_n = 2**1 else: try: tree_n = 2**math.ceil(math.log2(len(tiers))) except: tree_n = 2**1 print("---------->", tiers) print("!" * 100) tiers_n = len(tiers) for i in range(0, tree_n, 2): print(f"PAIR ---> {i}") tier_1 = None tier_2 = None if i < tiers_n: tier_1 = tiers[i].user_id if i + 1 < tiers_n: tier_2 = tiers[i + 1].user_id print(f"tier 1 -> {tier_1}") print(f"tier 2 -> {tier_2}") print() teams.append([tier_1, tier_2]) pprint(teams) store_matches = [] def _create_match(tournament_id, match_id, next_match_id, flag=0): print("======= MATCH ========") print(f"tournament_id = {tournament_id}") print(f"match_id = {match_id} --> {next_match_id}") print(f"flag = {flag}") match = Match( match_id=match_id, tournament_id=tournament_id, next_match_id=next_match_id, flag=flag, ) """ user_id_1 = db.Column(db.Integer, db.ForeignKey('user.id')) user_id_2 = db.Column(db.Integer, db.ForeignKey('user.id')) results = db.Column(db.Text) results_by_user_id_1 = db.Column(db.Text) results_by_user_id_2 = db.Column(db.Text) """ print("======================") return match match_id = 1 matches_n_cul = 0 for level in range(int(math.log2(tree_n))): matches = [] matches_n = int((tree_n / 2) / (2**level)) print(f"\033[91m===== {level} | {matches_n} =====\033[0m") for j in range(matches_n): matches.append(match_id) if match_id % 2 == 1: next_match_id = ((match_id - matches_n_cul + 1) // 2) \ + matches_n_cul + matches_n else: next_match_id = ((match_id - matches_n_cul + 0) // 2) \ + matches_n_cul + matches_n # print(f">>> {match_id} --> {next_match_id}") match = _create_match(tournament.id, match_id, next_match_id, flag=int(matches_n == 1)) if level == 0: print("ASSIGN", j, teams[j]) match.user_id_1 = teams[j][0] match.user_id_2 = teams[j][1] store_matches.append(match) match_id += 1 if matches_n == 1: print("3MATCH") matches.append(match_id) match = _create_match(tournament.id, match_id, None, flag=2) store_matches.append(match) match_id += 1 results.append(matches) matches_n_cul += matches_n pprint(results) import json print("------------") ladder_txt = json.dumps({"teams": teams, "results": results}) pprint(ladder_txt) print("------------") tournament.date_deadline = datetime.datetime.utcnow() tournament.date_start = datetime.datetime.utcnow() tournament.ladder = ladder_txt tournament.matches = [] for match in store_matches: tournament.matches.append(match) # XXX: find wildcards cached_ids = [] while 1: push_i = 0 for match in store_matches: push_user = None if (match.user_id_2 is None and match.user_id_1 is not None and match.id not in cached_ids): push_user = match.user_id_1 cached_ids.append(match.id) if (match.user_id_1 is None and match.user_id_2 is not None and match.id not in cached_ids): push_user = match.user_id_2 cached_ids.append(match.id) if push_user and match.next_match_id: match_next = (Match.query.filter( Match.tournament_id == match.tournament_id).filter( Match.match_id == match.next_match_id).first()) if match.match_id % 2 == 1: match_next.user_id_1 = push_user else: match_next.user_id_2 = push_user push_i = 1 print(f"{match} ==============================> PUSH") s.db.session.commit() print() if push_i == 0: break s.db.session.commit()
def match_new(idx): from app.models import Match, User match = (Match.query.filter(Match.id == idx).first()) from app.models import Tournament tournament = (Tournament.query.filter( Tournament.id == match.tournament_id).first()) auth_token = request.cookies.get('auth_token') user = app.action.user.user_instance_from_token(app_cls, auth_token) #################################################################### errors = {} successes = {} FORM_ARGS = { 'score_1': FORM_TOURNAMENT_VALID['score_1'], 'score_2': FORM_TOURNAMENT_VALID['score_2'], } parsed_args = {} user_1 = None user_2 = None if match.user_id_1: _user = (User.query.filter(User.id == match.user_id_1).first()) user_1 = _user if match.user_id_2: _user = (User.query.filter(User.id == match.user_id_2).first()) user_2 = _user if user.id not in [match.user_id_1, match.user_id_2]: return redirect(f'/tournament_display/{tournament.id}') ##### # fixme unpack score for user! results_by_user = None if user.id is match.user_id_1: results_by_user = match.results_by_user_id_1 if user.id is match.user_id_2: results_by_user = match.results_by_user_id_2 if results_by_user: parsed_args['score_1'], parsed_args['score_2'] = map( int, results_by_user.split("@")) if request.method == 'POST': try: parsed_args = parser.parse(FORM_ARGS, location="form") pprint(parsed_args) results_by_user = str(parsed_args['score_1']) + "@" + str( parsed_args['score_2']) ########################################### if user.id is match.user_id_1: match.results_by_user_id_1 = results_by_user if user.id is match.user_id_2: match.results_by_user_id_2 = results_by_user if match.results_by_user_id_1 == match.results_by_user_id_2: match.results = match.results_by_user_id_1 # FIXME: set winner WHO IS winner_id = None loser_id = None if parsed_args['score_1'] > parsed_args['score_2']: winner_id = match.user_id_1 loser_id = match.user_id_2 else: winner_id = match.user_id_2 loser_id = match.user_id_1 if match.next_match_id: match_next = (Match.query.filter( Match.tournament_id == match.tournament_id).filter( Match.match_id == match.next_match_id).first()) if match.match_id % 2 == 1: match_next.user_id_1 = winner_id else: match_next.user_id_2 = winner_id if match_next.flag == 1: # FIXME: for 3th place match_next_losers = \ (Match.query.filter(Match.tournament_id == match.tournament_id).filter(Match.match_id == match_next.next_match_id).first()) if match.match_id % 2 == 1: match_next_losers.user_id_1 = loser_id else: match_next_losers.user_id_2 = loser_id app_cls.service.db.session.commit() ########################################### successes = {"match": [f"The score was recorded."]} except DataError as e: errors = e.args[0]['form'] print("ERROR", errors) """ results = db.Column(db.Text) results_by_user_id_1 = db.Column(db.Text) results_by_user_id_2 = db.Column(db.Text) #return redirect(f'/tournament_display/{tournament.id}') """ return render_template('match_new.html', match=match, tournament=tournament, user_1=user_1, user_2=user_2, errors=errors, successes=successes, parsed_args=parsed_args)