def add_player_to_machine_from_queue(division_machine_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,
division_machine_id)
division = fetch_entity(tables.Division, division_machine.division_id)
if division.active is False:
raise BadRequest('Division is not active')
if len(division_machine.queue) == 0:
raise BadRequest('Trying to add player from an empty queue')
if division_machine.player_id is not None:
raise BadRequest(
'Trying to add player from a queue to a machine in use')
root_queue = tables.Queue.query.filter_by(
division_machine_id=division_machine_id, parent_id=None).first()
player = fetch_entity(tables.Player, root_queue.player_id)
if check_player_team_can_start_game(
current_app, division_machine, player=player) is False:
raise BadRequest(
'Player can not start game - either no tickets or already on another machine'
)
with db.session.no_autoflush:
try:
queues_to_lock = tables.Queue.query.with_for_update().filter_by(
division_machine_id=division_machine.division_machine_id).all(
)
players_to_alert = get_player_list_to_notify(
player.player_id, division_machine)
set_token_start_time(current_app,
player,
division_machine,
commit=False)
division_machine.player_id = root_queue.player_id
if len(root_queue.queue_child) > 0:
root_queue.queue_child.remove(root_queue.queue_child[0])
db.session.delete(root_queue)
create_audit_log_ex(
current_app,
"Player added to machine from queue",
user_id=current_user.user_id,
player_id=player.player_id,
division_machine_id=division_machine.division_machine_id,
description="Player added to machine %s queue by %s" %
(division_machine.machine.machine_name, current_user.username),
commit=False)
db.session.commit()
return_dict = {
'division_machine': division_machine.to_dict_simple()
}
if len(players_to_alert) > 0:
send_push_notification(
"The queue for %s has changed! Please check the queue to see your new position."
% division_machine.machine.machine_name,
players=players_to_alert)
return jsonify({'data': division_machine.to_dict_simple()})
except Exception as e:
db.session.commit()
raise e
def route_get_or_change_division_final_qualifiers(division_final_id):
division_final = fetch_entity(current_app.tables.DivisionFinal,
division_final_id)
division = fetch_entity(current_app.tables.Division,
division_final.division_id)
if request.data:
rollcall_list = json.loads(request.data) #['data']
else:
sorted_player_list = sorted([
division_final_player.to_dict_simple()
for division_final_player in division_final.qualifiers
],
key=lambda e: e['initial_seed'])
for index, player in enumerate(sorted_player_list):
sorted_player_list[index]['removed'] = False
sorted_player_list[index]['reranked_seed'] = sorted_player_list[
index]['initial_seed']
rollcall_list = create_simplified_division_results(
sorted_player_list, division.finals_num_qualifiers, current_app)
modified_rollcall_list = remove_missing_final_player(
rollcall_list, current_app)
divided_rollcall_list = create_simplified_division_results(
modified_rollcall_list, division.finals_num_qualifiers, current_app)
return jsonify({'data': divided_rollcall_list})
def route_add_division_machine_team(division_id,division_machine_id,team_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,division_machine_id)
team = fetch_entity(tables.Team,team_id)
if division_machine.team_id or division_machine.player_id:
raise Conflict('The machine is already being played')
if check_player_team_can_start_game(current_app,division_machine,team=team) is False:
raise BadRequest('Player can not start game - either no tickets or already on another machine')
if tables.DivisionMachine.query.filter_by(player_id=team.players[0].player_id).first() or tables.DivisionMachine.query.filter_by(player_id=team.players[1].player_id).first():
raise BadRequest('Team can not start game - one player is playing on another machine')
set_token_start_time(current_app,None,division_machine,team_id=team_id)
division_machine.team_id=team.team_id
tables.db_handle.session.commit()
players_to_alert = []
removed_queues = []
for player in team.players:
queue = tables.Queue.query.filter_by(player_id=player.player_id).first()
if queue:
players_to_alert = players_to_alert + get_player_list_to_notify(player.player_id,queue.division_machine)
removed_queue = remove_player_from_queue(current_app,player,commit=True)
removed_queues.append(removed_queue)
db.session.commit()
if all(item is not None and item is not False for item in removed_queues) and len(players_to_alert) > 0:
push_notification_message = "The queue for %s has changed! Please check the queue to see your new position." % queue.division_machine.machine.machine_name
send_push_notification(push_notification_message, players=players_to_alert)
return jsonify({'data':division_machine.to_dict_simple()})
def route_edit_meta_division(meta_division_id):
meta_division_data = json.loads(request.data)
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
# FIXME : need to load machines as part of init
meta_division = fetch_entity(tables.MetaDivision, int(meta_division_id))
if 'divisions' in meta_division_data:
for division in meta_division_data['divisions']:
division_table = fetch_entity(tables.Division, int(division))
meta_division.divisions.append(division_table)
for division in meta_division.divisions:
if str(division.division_id
) not in meta_division_data['divisions']:
meta_division.divisions.remove(division)
if 'meta_division_name' in meta_division_data:
meta_division.meta_division_name = meta_division_data[
'meta_division_name']
if 'discount_ticket_count' in meta_division_data:
meta_division.discount_ticket_count = meta_division_data[
'discount_ticket_count']
if 'discount_ticket_price' in meta_division_data:
meta_division.discount_ticket_price = meta_division_data[
'discount_ticket_price']
if 'discount_stripe_sku' in meta_division_data and meta_division_data[
'discount_stripe_sku']:
meta_division.discount_stripe_sku = meta_division_data[
'discount_stripe_sku']
tables.db_handle.session.commit()
return jsonify({'data': meta_division.to_dict_simple()})
def route_complete_division_final_round(division_final_round_id):
division_final_round = fetch_entity(current_app.tables.DivisionFinalRound,
division_final_round_id)
division_final = fetch_entity(current_app.tables.DivisionFinal,
division_final_round.division_final_id)
winners = complete_round(division_final, division_final_round, current_app)
return jsonify({'data': None})
def route_get_tiebreakers(division_final_id):
division_final = fetch_entity(current_app.tables.DivisionFinal,
division_final_id)
division = fetch_entity(current_app.tables.Division,
division_final.division_id)
tiebreakers = get_tiebreakers_for_division(division_final.qualifiers,
division.finals_num_qualifiers)
return jsonify({'data': {'tiebreakers': tiebreakers}})
def route_add_division_machine_player(division_id,division_machine_id,player_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,division_machine_id)
player = fetch_entity(tables.Player,player_id)
if division_machine.division.active is False:
raise Conflict("Division is not active.")
if division_machine.removed is True:
raise Conflict("Machine is not active. You have been very naughty.")
if player.active is False:
raise Conflict('Player is not active. Please see the front desk.')
if division_machine.player_id or division_machine.team_id:
raise Conflict('Machine is already being played')
if check_player_team_can_start_game(current_app,division_machine,player) is False:
raise BadRequest('Player can not start game - either no tickets or already on another machine')
if len(player.teams) > 0:
if tables.DivisionMachine.query.filter_by(team_id=player.teams[0].team_id).first():
raise BadRequest('Player can not start game - his team is playing on another machine')
set_token_start_time(current_app,player,division_machine,commit=False)
create_audit_log_ex(current_app, "Game Started",
user_id=current_user.user_id,
player_id=player.player_id,
division_machine_id=division_machine.division_machine_id,
commit=False)
division_machine.player_id=player.player_id
##db.session.commit()
queue = tables.Queue.query.filter_by(player_id=player.player_id).first()
players_to_alert = []
players_in_other_queue = []
if queue:
players_to_alert = get_player_list_to_notify(player.player_id,queue.division_machine)
players_in_other_queue = get_players_in_queue_after_player(player.player_id)
removed_queue = remove_player_from_queue(current_app,player,commit=True)
if removed_queue and removed_queue is not False:
create_audit_log_ex(current_app, "Player removed from queue",
user_id=current_user.user_id,
player_id=player.player_id,
division_machine_id=removed_queue.division_machine_id,
description="Player removed from queue %s by getting started on %s" % (removed_queue.division_machine.machine.machine_name,division_machine.machine.machine_name),
commit=False)
for player_in_other_que in players_in_other_queue:
create_audit_log_ex(current_app, "Other player removed from queue",
user_id=current_user.user_id,
player_id=player_in_other_que['player_id'],
division_machine_id=player_in_other_que['division_machine_id'],
description="Player moved up on queue %s due to removal of player %s" % (player_in_other_que['division_machine']['division_machine_name'],player.first_name+" "+player.last_name),
commit=False)
if removed_queue is not None and removed_queue is not False and len(players_to_alert) > 0:
push_notification_message = "The queue for %s has changed! Please check the queue to see your new position." % queue.division_machine.machine.machine_name
send_push_notification(push_notification_message, players=players_to_alert)
db.session.commit()
return jsonify({'data':division_machine.to_dict_simple()})
def route_generate_brackets(division_final_id):
division_final = fetch_entity(current_app.tables.DivisionFinal,
division_final_id)
division = fetch_entity(current_app.tables.Division,
division_final.division_id)
rollcall_list = json.loads(request.data) #['data']
final_rounds = generate_brackets(current_app, division_final_id,
rollcall_list,
division.finals_num_qualifiers)
final_rounds_dicts = [
final_round.to_dict_simple() for final_round in final_rounds
]
return jsonify({'data': to_dict(final_rounds_dicts)})
def route_scorekeeping_round_reopen(division_final_round_id):
division_final_round_to_reopen = fetch_entity(
current_app.tables.DivisionFinalRound, division_final_round_id)
division_final = fetch_entity(
current_app.tables.DivisionFinal,
division_final_round_to_reopen.division_final_id)
division_final_rounds = [
division_final_round
for division_final_round in division_final.division_final_rounds
if division_final_round.round_number >
division_final_round_to_reopen.round_number
]
division_final_round_to_reopen.completed = False
undo_final_round(division_final_rounds, current_app)
return jsonify({'data': None})
def route_record_tiebreaker_results(division_final_id):
tiebreaker_results = json.loads(request.data)
division_final = fetch_entity(current_app.tables.DivisionFinal,
division_final_id)
tiebreaker_results_with_new_ranks = record_tiebreaker_results(
division_final.qualifiers, tiebreaker_results, current_app)
return jsonify({'data': tiebreaker_results_with_new_ranks})
def create_meta_division(app,meta_division_data):
db = db_util.app_db_handle(app)
tables = db_util.app_db_tables(app)
new_meta_division = tables.MetaDivision(
)
if 'meta_division_name' in meta_division_data:
new_meta_division.meta_division_name=meta_division_data['meta_division_name']
if 'divisions' in meta_division_data:
for division in meta_division_data['divisions']:
division_table = fetch_entity(tables.Division,int(division))
new_meta_division.divisions.append(division_table)
if 'use_stripe' in meta_division_data and meta_division_data['use_stripe']:
new_meta_division.use_stripe = True
if get_valid_sku(meta_division_data['stripe_sku'],app.td_config['STRIPE_API_KEY'])['sku'] is None:
raise BadRequest('invalid SKU specified')
new_meta_division.stripe_sku=meta_division_data['stripe_sku']
if 'discount_stripe_sku' in meta_division_data and meta_division_data['discount_stripe_sku']:
if get_valid_sku(meta_division_data['discount_stripe_sku'],app.td_config['STRIPE_API_KEY'])['sku'] is None:
raise BadRequest('invalid SKU specified')
new_meta_division.discount_stripe_sku=meta_division_data['discount_stripe_sku']
new_meta_division.discount_ticket_count=meta_division_data['discount_ticket_count']
set_stripe_api_key(app.td_config['STRIPE_API_KEY'])
fetch_stripe_price(app,new_meta_division)
else:
new_meta_division.use_stripe = False
if 'local_price' in meta_division_data and meta_division_data['use_stripe'] == False:
new_meta_division.local_price=meta_division_data['local_price']
tables.db_handle.session.add(new_meta_division)
tables.db_handle.session.commit()
return new_meta_division
def route_update_user(user_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
user = fetch_entity(tables.User, user_id)
input_data = json.loads(request.data)
if 'username' not in input_data:
raise BadRequest("You did not specify a username")
if input_data['username'] != user.username:
user.username = input_data['username']
if 'has_picture' in input_data:
user.has_picture = True
if 'password' in input_data:
user.crypt_password(input_data['password'])
if 'roles' in input_data:
check_roles_exist(tables, input_data['roles'])
roles = current_app.tables.Role.query.all()
user_roles = user.roles
for role in roles:
if role in user_roles and str(
role.role_id) not in input_data['roles']:
#print "removing %s"%role.name
user.roles.remove(role)
if role not in user_roles and str(
role.role_id) in input_data['roles']:
#print "removing %s"%role.name
user.roles.append(role)
if 'pic_file' in input_data:
os.system('mv %s/%s /var/www/html/pics/user_%s.jpg' %
(current_app.config['UPLOAD_FOLDER'], input_data['pic_file'],
user.user_id))
db.session.commit()
return jsonify({'data': user.to_dict_simple()})
def route_initialize_division_final(division_id):
division_id = int(division_id)
division = fetch_entity(current_app.tables.Division, division_id)
if 'file' in request.files:
file = request.files['file']
filename = secure_filename(file.filename)
random_file_name = datetime.datetime.now().strftime("%s")
save_path = os.path.join(current_app.config['UPLOAD_FOLDER'],
"%s.csv" % random_file_name)
file.save(save_path)
file.close()
division_results = []
with open(save_path, 'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',', quotechar='|')
for row in reader:
new_player = create_player(current_app, {
'first_name': row[0],
'last_name': ''
})
division_results.append((int(row[1]) - 1, {
'player_id': new_player.player_id,
'sum': 0,
'ifpa_ranking': '0',
'player_name': row[0]
}))
else:
division_results = get_division_results(division_id, return_json=False)
division_results = division_results['data']['ranked_player_list'][
division_id]
division_final = initialize_division_final(division_id,
division.division_name,
division_results, current_app)
return jsonify({'data': division_final.to_dict_simple()})
def confirm_tokens(tokens):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
#tokens_data = json.loads(request.data)['total_tokens']
#for token in tokens_data:
for token in tokens:
token = fetch_entity(tables.Token, token['token_id'])
if token:
token.paid_for = True
tables.db_handle.session.commit()
audit_log = tables.AuditLog()
audit_log.purchase_date = datetime.datetime.now()
if token.player_id:
audit_log.player_id = token.player_id
if token.team_id:
audit_log.team_id = token.team_id
audit_log.token_id = new_token.token_id
audit_log.deskworker_id = current_user.user_id
tokens_left_string = calc_audit_log_remaining_tokens(
player_id, team_id)
audit_log.remaining_tokens = tokens_left_string
db.session.add(audit_log)
tables.db_handle.session.commit()
#DB.session.add(new_audit_log_entry)
#tables.db_handle.session.commit()
db.session.commit()
return jsonify({'data': token.to_dict_simple()})
def route_delete_division_machine(division_id,division_machine_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,division_machine_id)
division_machine.removed=True
tables.db_handle.session.commit()
return jsonify({'data':division_machine.to_dict_simple()})
def route_remove_division_machine_team(division_id,division_machine_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,division_machine_id)
if division_machine.team_id is None:
raise BadRequest('No team playing on this machine')
division_machine.team_id=None
tables.db_handle.session.commit()
return jsonify({'data':division_machine.to_dict_simple()})
def get_queue_for_player(player_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
player = fetch_entity(tables.Player, player_id)
queue = tables.Queue.query.filter_by(player_id=player_id).first()
if queue:
return jsonify({'data': queue.to_dict_simple()})
else:
return jsonify({'data': None})
def route_audit_log_missing_scores(player_id,audit_log_id,minutes):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
users = {user.user_id:user.to_dict_simple() for user in tables.User.query.all()}
divisions = {division.division_id:division.to_dict_simple() for division in tables.Division.query.all()}
metadivisions = {meta_division.meta_division_id:meta_division.to_dict_simple() for meta_division in tables.MetaDivision.query.all()}
division_machines = {division_machine.division_machine_id:division_machine.to_dict_simple() for division_machine in tables.DivisionMachine.query.all()}
players = {player.player_id:player.to_dict_simple() for player in tables.Player.query.all()}
teams = {team.team_id:team.to_dict_simple() for team in tables.Team.query.all()}
audit_log_base = fetch_entity(tables.AuditLog,audit_log_id)
if audit_log_base.action_date:
audit_log_base_date = audit_log_base.action_date
#if audit_log_base.game_started_date:
# audit_log_base_date = audit_log_base.game_started_date
audit_log_end_range = audit_log_base_date+datetime.timedelta(minutes=int(minutes))
print "%s - %s" % (audit_log_base_date,audit_log_end_range)
division_id = audit_log_base.token.division_id
metadivision_id = audit_log_base.token.metadivision_id
audit_logs_query = tables.AuditLog.query
if metadivision_id:
div_string = " for metadivision %s" % metadivisions[metadivision_id]['meta_division_name']
audit_logs_query = audit_logs_query.filter(tables.AuditLog.token.has(metadivision_id=metadivision_id))
else:
div_string = " for division %s" % divisions[division_id]['tournament_name']
audit_logs_query = audit_logs_query.filter(tables.AuditLog.token.has(division_id=division_id))
audit_logs_query=audit_logs_query.filter_by(action="Score Added")
audit_logs = audit_logs_query.filter(
and_(
tables.AuditLog.action_date >= audit_log_base_date,
tables.AuditLog.action_date <= audit_log_end_range
)
).order_by(asc(tables.AuditLog.action_date)).all()
#audit_logs = audit_logs_query.all()
audit_log_list = []
audit_log_index = 0
print len(audit_logs)
for audit_log in audit_logs:
#while audit_log_index < len(audit_logs):
#audit_log=audit_logs[audit_log_index]
if audit_log.division_machine_id:
machine_name=division_machines[audit_log.division_machine_id]['division_machine_name']
if audit_log.team_id:
player_team_string = "team %s " % teams[audit_log.team_id]['team_name']
else:
player_team_string = "player %s "% players[audit_log.player_id]['first_name']+" "+players[audit_log.player_id]['first_name']
if audit_log.action == "Voided":
continue
division_machine_name = division_machines[audit_log.division_machine_id]['division_machine_name']
score = locale.format("%d",audit_log.entry.scores[0].score,grouping=True)
audit_log_list.append({
'audit_log_id':audit_log.audit_log_id,
'contents': [audit_log.action_date,audit_log.action,player_team_string,score,division_machine_name]
})
return jsonify({'data':audit_log_list})
def route_get_division_machines_longest_playtime(division_id,division_machine_id):
f = open('/tmp/workfile%s'%division_id, 'w')
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
if division_machine_id == "0":
if division_id == "0":
division_machines = tables.DivisionMachine.query.all()
else:
division_machines = tables.DivisionMachine.query.filter_by(division_id=division_id).all()
else:
division_machines = [fetch_entity(tables.DivisionMachine,division_machine_id)]
division_machine_names = {division_machine.division_machine_id:division_machine.machine.machine_name for division_machine in tables.DivisionMachine.query.all()}
print division_machine_names
division_machine_ids = [division_machine.division_machine_id for division_machine in division_machines]
audit_logs = tables.AuditLog.query.filter(and_(tables.AuditLog.division_machine_id.in_(division_machine_ids),
or_(tables.AuditLog.action == action for action in ('Game Started',
'Score Added',
'Score Voided',
'Jagoff Declared',
'Player Removed')
))).order_by(asc(tables.AuditLog.audit_log_id)).all()
start_times = {}
avg_times = {}
for audit_log in audit_logs:
if audit_log.action == "Game Started":
start_times[audit_log.division_machine_id] = audit_log.action_date
if audit_log.action == "Score Added" or audit_log.action == "Score Voided" or audit_log.action == "Jagoff Declared":
if audit_log.division_machine_id not in avg_times:
avg_times[audit_log.division_machine_id]=[]
epoch = datetime.datetime.fromtimestamp(0)
start_time=(start_times[audit_log.division_machine_id]-epoch).total_seconds()
end_time = (audit_log.action_date - epoch).total_seconds()
#f.write(str(datetime.datetime.fromtimestamp(start_time))+" "+str(datetime.datetime.fromtimestamp(end_time))+" "+str(start_time)+" "+str(end_time)+"\n")
json_string = "{\"start_time\":\"%s\",\"end_time\":\"%s\",\"machine\":\"%s\",\"player\":\"%s\"},\n"%(str(start_time),
str(end_time),
division_machine_names[audit_log.division_machine_id],
audit_log.player_id
)
f.write(json_string)
time_delta = audit_log.action_date - start_times[audit_log.division_machine_id]
division_machine = tables.DivisionMachine.query.filter_by(division_machine_id=audit_log.division_machine_id).first()
#f.write(str(time_delta.total_seconds()/60)+" ("+str(time_delta.total_seconds())+") on "+ division_machine.machine.machine_name +" ("+str(audit_log.audit_log_id)+")\n")
avg_times[audit_log.division_machine_id].append(time_delta.total_seconds())
for avg_time_division_machine_id,machine_times in avg_times.iteritems():
total_time = 0
avg_game_time = 0
total_time = sum(machine_times)
avg_game_time = total_time/len(machine_times)
division_machine = tables.DivisionMachine.query.filter_by(division_machine_id=avg_time_division_machine_id).first()
division_machine.avg_play_time = datetime.datetime.fromtimestamp(avg_game_time).strftime('%M min')
db.session.commit()
f.close()
return jsonify({})
def start_pre_reg_sale():
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
stripe_token = json.loads(request.data)['stripe_token']
player_id = json.loads(request.data)['player_id']
email = json.loads(request.data)['player_email']
cc_email = json.loads(request.data)['player_cc_email']
stripe.api_key = current_app.td_config['STRIPE_API_KEY']
registration_sku = os.getenv('REGISTRATION_FEE_SKU', None)
stripe_items = [{"quantity": 1, "type": "sku", "parent": registration_sku}]
player = fetch_entity(tables.Player, player_id)
try:
order = stripe.Order.create(currency="usd",
email=cc_email,
items=stripe_items)
order_response = order.pay(source=stripe_token)
order_id_string = "order_id %s, " % order_response.id
create_audit_log("Player Ticket Registration Completed",
datetime.datetime.now(),
order_id_string,
None,
player_id=int(player_id))
player.pre_reg_paid = True
db.session.commit()
player_dict = player.to_dict_simple()
player_dict['pin'] = player.pin
sg = sendgrid.SendGridAPIClient(
apikey=current_app.td_config['SENDGRID_API_KEY'])
from_email = Email("*****@*****.**")
subject = "You have been pre-registered for PAPA 20!"
to_email = Email(email)
content = Content(
"text/plain",
"Your player number is : %s\n\nYour player PIN is : %s\n\n\n\nBelow is information you will need to complete the registration process.\n\n\n\nThe PAPA 20 World Championship starts on April 6th, but the PAPA facility will be open to the public on April 5th during the PAPA Circuit Final. Starting on April 5th at 1pm you will be able to complete the registration process. You will need to go to the front desk and fill out your legal waiver and pick up your PAPA 20 t-shirt.\n\n\n\nYou will be unable to play any games until you sign the waiver.\n\n\n\nIf you have any questions, please email [email protected]\n\n\n\nWe look forward to seeing you at PAPA 20!"
% (player.player_id, player.pin))
mail = Mail(from_email, subject, to_email, content)
response = sg.client.mail.send.post(request_body=mail.get())
return jsonify({'data': player_dict})
except stripe.error.CardError as e:
# The card has been declined
for charge in stripe.Charge.list(limit=20):
if charge.order == order.id:
if charge.outcome[
'reason'] == 'highest_risk_level' or charge.outcome[
'network_status'] == 'declined_by_network':
raise BadRequest(
'Your card was rejected by the credit card processing service. Please check to make sure you entered the number correctly, or try another card, or send email to [email protected]'
)
print charge.outcome
#print order
#stripe.Charge.retrieve(order_response.charge)
return jsonify({"data": "FAILURE"})
def route_add_division_machine(division_id):
machine_data = json.loads(request.data)
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division = fetch_entity(tables.Division,division_id)
# FIXME : need to load machines as part of init
if 'machine_id' in machine_data:
machine = fetch_entity(tables.Machine,int(machine_data['machine_id']))
else:
BadRequest('no machine_id specified')
existing_division_machine = tables.DivisionMachine.query.filter_by(division_id=division_id,machine_id=machine.machine_id).first()
if existing_division_machine is None:
new_division_machine = create_division_machine(current_app,machine,division)
return jsonify({'data':new_division_machine.to_dict_simple()})
if existing_division_machine:
existing_division_machine.removed = False
db.session.commit()
return jsonify({'data':existing_division_machine.to_dict_simple()})
def route_get_top_player_entry(player_id,division_machine_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,division_machine_id)
top_player_score_for_machine = tables.Score.query.filter_by(division_machine_id=division_machine_id).join(tables.Entry).filter_by(player_id=player_id,voided=False).order_by(desc(tables.Score.score)).first()
if top_player_score_for_machine:
top_score = top_player_score_for_machine.score
else:
top_score = None
return jsonify({'data':top_score})
def insert_player_into_queue(player_id, division_machine_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,
division_machine_id)
player = fetch_entity(tables.Player, player_id)
with db.session.no_autoflush:
try:
queues_to_lock = tables.Queue.query.with_for_update().filter_by(
division_machine_id=division_machine.division_machine_id).all(
)
queue = tables.Queue.query.filter_by(
player_id=player.player_id).first()
head_of_queue = tables.Queue.query.filter_by(
division_machine_id=division_machine_id,
parent_id=None).first()
if queue:
if queue.division_machine_id == division_machine.division_machine_id:
raise BadRequest('Player is already on this queue.')
else:
raise BadRequest(
'Player is currently on another queue. Remove the player and try again.'
)
if head_of_queue is None:
raise BadRequest(
'Tried to insert into a machine with no one on the queue')
#head_of_queue = division_machine.queue[0]
new_queue = tables.Queue(player=player,
division_machine=division_machine)
db.session.add(new_queue)
division_machine.queue.append(new_queue)
new_queue.queue_child.append(head_of_queue)
db.session.commit()
return jsonify({'data': ''})
except Exception as e:
db.session.commit()
print "poop %s" % e
raise e
pass
def create_team(app,team_data):
db = db_util.app_db_handle(app)
tables = db_util.app_db_tables(app)
team = app.tables.Team(
team_name=team_data['team_name']
)
db.session.add(team)
db.session.commit()
for player_id in team_data['players']:
team.players.append(fetch_entity(tables.Player,player_id))
db.session.commit()
return team
def route_change_score(score_id,score):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
score_obj = fetch_entity(tables.Score,score_id)
score_obj.score=score
create_audit_log_ex(current_app, "Score Changed By Admin",
user_id=current_user.user_id,
player_id=score_obj.entry.player_id,
division_machine_id=score_obj.division_machine_id,
commit=False,description="new score : %s"%score)
db.session.commit()
return jsonify({'data':None})
def route_admin_add_score(division_machine_id,score,player_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_id=fetch_entity(tables.DivisionMachine,division_machine_id).division_id
entry = create_entry(current_app,division_machine_id,division_id,score,player_id)
create_audit_log_ex(current_app, "Admin inserted new score",
user_id=current_user.user_id,
player_id=player_id,
division_machine_id=division_machine_id,
commit=False,description="New score added on %s : %s"%(entry.scores[0].division_machine.machine.machine_name,score))
db.session.commit()
return jsonify({'data':entry.entry_id})
def route_get_help(division_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division = fetch_entity(tables.Division, division_id)
pageable_users = tables.User.query.filter(
tables.User.roles.any(name='pageable')).all()
for pageable_user in pageable_users:
print "pushing"
send_push_notification("HELP IS NEEDED IN %s." %
division.division_name,
user_id=pageable_user.user_id,
title="SEND IN THE CAVALRY")
return jsonify({})
def route_edit_division_machine(division_machine_id):
machine_data = json.loads(request.data)
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,division_machine_id)
if 'pic_file' in machine_data:
os.system('mv %s/%s /var/www/html/pics/machine_%s.jpg' % (current_app.config['UPLOAD_FOLDER'],
machine_data['pic_file'],
division_machine.division_machine_id))
# FIXME : need to load machines as part of init
return jsonify({'data':division_machine.to_dict_simple()})
def route_undo_division_machine_player_team(division_id,division_machine_id):
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
division_machine = fetch_entity(tables.DivisionMachine,division_machine_id)
if division_machine.division.team_tournament is False and division_machine.player_id is None:
raise Conflict('Machine is not being played')
if division_machine.division.team_tournament and division_machine.team_id is None:
raise Conflict('Machine is not being played')
token = tables.Token.query.filter_by(player_id=division_machine.player_id,division_machine_id=division_machine_id,used=False).first()
token.division_machine_id=None
division_machine.player_id=None
db.session.commit()
return jsonify({'data':division_machine.to_dict_simple()})
def test_lock_queue():
db = db_util.app_db_handle(current_app)
tables = db_util.app_db_tables(current_app)
#queue = db.session.query(tables.Queue).with_for_update().filter_by(queue_id=3687).first()
queue = tables.Queue.query.with_for_update().filter_by(
division_machine_id=11).all()
#players = {player.player_id:player.to_dict_fast() for player in tables.Player.query.all() if player.active is True}
queue[0].player_id = 89
db.session.commit()
queue_list = []
division_machine = fetch_entity(tables.DivisionMachine, 11)
for queue in division_machine.queue:
queue_list.append(queue.to_dict_simple())
return jsonify({'data': queue_list})
