def unregister_member_from_tournament_play(request):
"""
POST -- Given a member_id, mark member as not participating in tournament
:param request:
:return:
"""
post_dict = dict(request.POST.items())
validate_keys(["member_id"], post_dict)
member_id = post_dict["member_id"]
# Check if member is even participating in a tournament in the first place
rawquery = Member.objects.raw(
"SELECT * FROM api_member WHERE interested_ptr_id=%s", [member_id])
if len(list(rawquery)) > 0:
member = rawquery[0]
if member.in_tournament == 0:
return http_response(
message="Member was not in a tournament to begin with",
code=400)
else:
return http_response(message="Specified member does not exist",
code=400)
return run_connection(
"UPDATE api_member SET in_tournament=0 WHERE interested_ptr_id=%s",
member_id)
def campaignRouter(request):
"""
POST -- Edits the corresponding campaign
Required Keys: id
Optional Keys: job, email
DELETE -- Deletes a campaign
Required Keys: id
:param request:
:return:
"""
if request.method == "POST":
dict_post = dict(request.POST.items())
validate_keys(["id", "job", "pitch", "email"], dict_post)
return edit_campaign(dict_post)
elif request.method == "DELETE":
# django doesn't have anything that handles delete so...
dict_delete = json.loads(request.body.decode('utf8').replace("'", '"'))
print(dict_delete)
if not validate_keys(["id", "job", "email"], dict_delete):
HttpResponse(json.dumps({'message': 'Missing parameters'}),
content_type='application/json',
status=400)
print(dict_delete)
return delete_campaign(dict_delete["id"], dict_delete["email"],
dict_delete["job"])
def get_bracket_node(request):
dict_get = dict(request.GET.items())
validate_keys(['tournament_id', 'level', 'index'], dict_get)
tournament_id = int(dict_get['tournament_id'])
level = int(dict_get['level'])
index = int(dict_get['index'])
nodes = BracketNode.objects.raw(
"SELECT * FROM api_bracketnode WHERE tournament_id = %s AND sibling_index = %s AND level = %s",
[tournament_id, index, level])
if len(list(nodes)) > 0:
node = nodes[0]
node_dict = serializeModel(node)
matches_array = []
# Get the matches associated with this bracket node
node_matches = Match.objects.raw(
"SELECT * FROM api_match WHERE bracket_node_id=%s", [node.id])
if len(list(node_matches)) > 0:
for node_match in list(node_matches):
node_match_dict = serializeModel(node_match)
matches_array.append(node_match_dict)
node_dict["matches"] = matches_array
print("BRACKET NODE DICT: " + str(node_dict))
context = {'bracket_node': node_dict}
return http_response(context)
else:
return http_response(message='No such bracket node', code=400)
def register_member_for_tournament_play(request):
"""
POST -- Given a member_id, mark the member as participating in a tournament.
:param request:
:return:
"""
post_dict = dict(request.POST.items())
validate_keys(["member_id"], post_dict)
member_id = post_dict["member_id"]
# Check if member is already participating in a tournament
rawquery = Member.objects.raw(
"SELECT * FROM api_member WHERE interested_ptr_id=%s", [member_id])
if len(list(rawquery)) > 0:
member = rawquery[0]
if member.in_tournament == 1:
return http_response(message="Member is already in a tournament",
code=400)
else:
return http_response(message="Specified member does not exist",
code=400)
return run_connection(
"UPDATE api_member SET in_tournament=1 WHERE interested_ptr_id=%s",
member_id)
def create_queue(request):
"""
POST -- need the queue_type key (CASUAL, RANKED, KOTH)
:param request:
:return:
"""
if request.method == "POST":
dict_post = dict(request.POST.items())
validate_keys('queue_type', dict_post)
return call_create_queue(dict_post["queue_type"])
def settingsBoardMemberRouter(request):
"""
Allow board members to get/edit list of boardmembers.
Expect input/output dictionary to be of the form
{
'boardmembers': [
{
'member_id': _
'first_name': _
'last_name': _
'email': _
'job': _
},
...
]
}
:param request:
:return:
"""
session_id = id_for_member(request.user.email)
if request.method == "GET":
return boardmembers_config()
elif request.method == "POST":
# Can only change their jobs
json_post_data = json.loads(request.body)
if not validate_keys(["boardmembers"], json_post_data):
HttpResponse(json.dumps(
{'message': 'Missing parameters member_id or job'}),
content_type='application/json',
status=400)
return boardmembers_config_edit(json_post_data)
def settingsRouter(request):
"""
Allow members to get and edit their own settings.
Expect input/output dictionary to be of the form
{
'private': _,
'bio': _
}
:param request:
:return:
"""
session_id = id_for_member(request.user.email)
if request.method == "GET":
if session_id is None:
return HttpResponse(json.dumps({"message": "No such member"}),
content_type="application/json")
return member_config(session_id)
elif request.method == "POST":
dict_post = dict(request.POST.items())
if not validate_keys(["private", "bio"], dict_post):
HttpResponse(json.dumps(
{'message': 'Missing parameters private or bio'}),
content_type='application/json',
status=400)
if session_id is None:
return HttpResponse(json.dumps({"message": "No such member"}),
content_type="application/json")
return member_config_edit(session_id, dict_post)
def settingsQueueRouter(request):
"""
Allows boardmembers to get all the current queues in db or add more queue types
Expect the input/output dictionary to be of the form
{
'queues': [
{
'queue_id': _,
'queue_type': _
},
...
]
}
:param request:
:return:
"""
session_id = id_for_member(request.user.email)
if not is_board_member(session_id):
return HttpResponse(json.dumps(
{"message": "You are not a board member."}),
content_type="application/json")
if request.method == "GET":
return get_all_queues_formatted()
elif request.method == "POST":
# Used to add more queue types to the db
# dict_post = dict(request.POST.items()) <- For some reason, can't read POST dictionary from PostMan like this
json_post_data = json.loads(request.body)
if not validate_keys('queues', json_post_data):
HttpResponse(json.dumps({'message': 'Missing parameter queues'}),
content_type='application/json',
status=400)
return add_queues_formatted(json_post_data)
elif request.method == "DELETE":
# The input dictionary should hold information ONLY for the queues to be deleted
json_delete_data = json.loads(request.body)
if not validate_keys('queues', json_delete_data):
HttpResponse(json.dumps({'message': 'Missing parameter queues'}),
content_type='application/json',
status=400)
return delete_queues_formatted(json_delete_data)
def settingsSchedulesRouter(request):
"""
POST/DELETE -- Allows board members to get the whole schedule and add to/edit/delete from schedule
Expect input/output dictionary to be of the form
{
'schedule': [
{
'date': _,
'number_of_courts': _
},
...
]
}
:param request:
:return:
"""
session_id = id_for_member(request.user.email)
if not is_board_member(session_id):
return HttpResponse(json.dumps(
{"message": "You are not a board member."}),
content_type="application/json")
if request.method == "POST":
# INSERT or UPDATE
# dict_post = dict(request.POST.items())
print(request.body)
json_post_data = json.loads(request.body.decode('utf8'))
if not validate_keys(["schedule"], json_post_data):
HttpResponse(json.dumps({'message': 'Missing parameter schedule'}),
content_type='application/json',
status=400)
return addto_edit_schedule(json_post_data)
elif request.method == "DELETE":
# The provided dictionary should ONLY contain information on the entries that are
# intended to be deleted.
dict_delete = json.loads(request.body.decode('utf8').replace("'", '"'))
if not validate_keys(["schedule"], dict_delete):
HttpResponse(json.dumps({'message': 'Missing parameter schedule'}),
content_type='application/json',
status=400)
return delete_multiple_from_schedule(dict_delete)
def view_member_profile(request):
"""
input:
{
"id": int # Needs to be a valid member
}
"""
dict_get = dict(request.GET.items())
if not validate_keys(['id'] in dict_get):
return http_response(message='Missing id', code=400)
member_id = int(dict_get['id'])
return member_profile(member_id)
def campaignFindRouter(request):
"""
I should probably change this later so it's a get request but no one seems to be using this route anyway so
POST -- Takes json data with campaign id, job, and email to find a corresponding campaign
:param request:
:return:
"""
dict_post = dict(request.POST.items())
if not validate_keys(["id", "job", "email"], dict_post):
HttpResponse(json.dumps({'message': 'Missing parameters'}),
content_type='application/json',
status=400)
return get_campaign(dict_post["id"], dict_post["email"], dict_post["job"])
def add_queues_formatted(dict_post):
"""
POST
:return:
"""
queues = dict_post['queues']
for q in queues:
if validate_keys(['queue_type'], q):
queue_type = q['queue_type']
add_queue(queue_type)
return HttpResponse(json.dumps(
{"message": "Successfully added queue type."}),
content_type="application/json")
def delete_queues_formatted(dict_delete):
"""
DELETE
:param dict_delete:
:return:
"""
queues = dict_delete['queues']
for q in queues:
if validate_keys(['queue_id', 'queue_type'], q):
queue_type = q['queue_type']
delete_queue(queue_type)
return HttpResponse(json.dumps(
{"message": "Successfully deleted queue type."}),
content_type="application/json")
def finish_tournament_router(request):
"""
Finish a tournament on this date.
Expect the dictionary to be
{
"tournament_id": _
}
:param request:
:return:
"""
post_dict = dict(request.POST.items())
if not validate_keys(["tournament_id"], post_dict):
http_response(message="Missing parameter tournament_id", code=400)
return finish_tournament(post_dict)
def delete_member(request):
"""
DELETE -- (labeled as POST because Django doesn't handle DELETE)
Delete ONE member from the db completely
Example: {"member_id": 39}
:param request:
:return:
"""
# Here, the dictionary should be {"member_id": _}
post_dict = dict(request.POST.items())
if not validate_keys(["member_id"], post_dict):
HttpResponse(json.dumps({'message': 'Missing parameter member_id'}),
content_type='application/json',
status=400)
return delete_club_member(post_dict)
def add_match(request):
"""
Start a NEW match and associate it with the specified bracket node.
'team_A' and 'team_B' are both strings of comma-separated member_id's
Ex: ("2,3")
:param request:
:return:
"""
post_dict = dict(request.POST.items())
validate_keys(['bracket_node_id', 'team_A', 'team_B'], post_dict)
bracket_node_id = int(post_dict['bracket_node_id'])
team_A_str = post_dict['team_A']
team_A = team_A_str.split(',')
team_B_str = post_dict['team_B']
team_B = team_B_str.split(',')
# Assert bracket node exists
nodes = BracketNode.objects.raw(
"SELECT * FROM api_bracketnode WHERE id=%s", [bracket_node_id])
if len(list(nodes)) <= 0:
return http_response(message='Invalid bracket_node_id', code=400)
return add_match_call(bracket_node_id, team_A, team_B)
def settingsCourtRouter(request):
"""
Allows board members to get the info on all courts and add/edit courts.
Expect the input/output dictionary to be of the form
{
'courts': [
{
'court_id': _,
'queue_id': _
},
...
]
'court_types': [str, ...]
}
:param request:
:return:
"""
session_id = id_for_member(request.user.email)
if request.method == "GET":
return get_all_courts_formmated()
elif request.method == "POST":
# Used to add new courts OR change the queue types for the courts
json_post_data = request.POST
if not validate_keys('courts', json_post_data):
HttpResponse(json.dumps({'message': 'Missing parameter courts'}),
content_type='application/json',
status=400)
return addto_edit_courts_formatted(json_post_data)
elif request.method == "DELETE":
# The input dictionary should hold information ONLY for the courts to be deleted
json_delete_data = json.loads(request.body.decode('utf8'))
if not validate_keys('courts', json_delete_data):
HttpResponse(json.dumps({'message': 'Missing parameter courts'}),
content_type='application/json',
status=400)
return delete_courts_formatted(json_delete_data)
def delete_courts_formatted(dict_delete):
"""
DELETE
:param dict_delete:
:return:
"""
courts = dict_delete['courts']
print(courts)
for c in courts:
if validate_keys(['court_id'], c):
court_id = c['court_id']
delete_court(court_id)
return HttpResponse(json.dumps(
{"message": "Successfully deleted specified courts."}),
content_type="application/json")
def create_campaign(request):
"""
POST -- Takes json data with campaign job, pitch, and campaigner id to create a new campaign
Required Keys: job, pitch, id
:param request:
:return:
"""
dict_post = dict(request.POST.items())
jobKey = "job"
pitchKey = "pitch"
campaignerKey = "campaigner_id"
keys = [jobKey, pitchKey, campaignerKey]
if not validate_keys(keys, dict_post):
return http_response({}, message="Missing parameters", code=400)
job = dict_post[jobKey]
pitch = dict_post[pitchKey]
campaigner_id = dict_post[campaignerKey]
campaigner_query = """
SELECT * FROM api_interested WHERE api_interested.id = %s AND EXISTS(SELECT * FROM api_member WHERE interested_ptr_id = id)
"""
interesteds = Interested.objects.raw(campaigner_query, [campaigner_id])
if len(list(interesteds)) <= 0:
return http_response({},
message="No such member found",
status="down",
code=400)
interested = interesteds[0]
curr_election_dict = get_current_election()
curr_election = curr_election_dict['election']
if curr_election is not None:
return run_connection(
"INSERT INTO api_campaign (job, pitch, election_id, campaigner_id) VALUES\
(%s, %s, %s, %s)", job, pitch,
curr_election.id, interested.id)
else:
return http_response({},
message="There is no election to campaign for!",
status="down",
code=400)
def mail(request):
if request.method == "GET":
mailing_lists = [
{
"name": "Interested Members",
"key": interested_mail_key
},
{
"name": "Current Member",
"key": member_mail_key
},
{
"name": "Board Member",
"key": board_mail_key
}
]
return HttpResponse(json.dumps(mailing_lists), content_type="application/json")
elif request.method == "POST":
"""
Expecting
{
"mailing_list": str
"title": str
"body": str
}
"""
list_mail_key = "mailing_list"
title_mail_key = "title"
body_mail_key = "body"
keys = [list_mail_key, title_mail_key, body_mail_key]
if not validate_keys(keys, request.POST):
return HttpResponse("Missing key, one of %s".format(','.join(keys)), status=400)
emails = emails_for_key(request.POST[list_mail_key])
subject = request.POST[title_mail_key]
message = request.POST[body_mail_key]
send_mail(
subject,
message,
BFF_EMAIL,
emails,
fail_silently=False,
)
def cast_vote(request):
"""
POST -- Casts/updates a vote for the current election
Required Keys: campaign_id
:param request:
:param job:
:return:
"""
voter_id = get_member_id_from_email(request.user.email)
dict_post = dict(request.POST.items())
if not validate_keys(["campaign_id"], dict_post):
return http_response(message='Missing campaign_id', code=400)
campaign_id = int(dict_post['campaign_id'])
campaign_query = Campaign.objects.raw(
"SELECT * FROM api_campaign WHERE id = %s", [campaign_id])
if len(list(campaign_query)) == 0:
return http_response(message='Campaign does not exist')
campaign = campaign_query[0]
this_job = campaign.job
my_votes = Vote.objects.raw("SELECT * FROM api_vote WHERE voter_id = %s",
[voter_id])
for vote in my_votes:
if vote.campaign.job == this_job:
# Already voted for a campaign with the same job, must update
response = run_connection(
"UPDATE api_vote SET campaign_id = %s WHERE voter_id = %s",
campaign.id, voter_id)
return response
# add the vote
query = """
INSERT INTO api_vote(voter_id, campaign_id) VALUES(%s, %s)
"""
response = run_connection(query, voter_id, campaign.id)
return response
def create_tournament_router(request):
"""
POST function to create a new tournament entry.
Expect the input dictionary to be
{
"num_players": _
"tournament_type": _ (DOUBLES, SINGLES)
"elimination_type": _ (SINGLE)
}
:param request:
:return:
"""
post_dict = dict(request.POST.items())
if not validate_keys(
["num_players", "tournament_type", "elimination_type"], post_dict):
HttpResponse(json.dumps(
{'message': 'Missing parameters num_players or tournament_type'}),
content_type='application/json',
status=400)
return create_tournament(post_dict)
def add_member(request):
"""
POST -- Adds a member to the logged in user's party
Required Keys: id, delete
Optional Keys: queue_id, add_members, remove_members
NOTE: `add_members` and `remove_members` are comma separated lists of
member id's to add or remove from the party respectively
:param request:
:return:
"""
post_dict = dict(request.POST.items())
if not validate_keys(['member_id'], post_dict):
return http_response({}, message="Keys not found", code=400)
member_id = post_dict['member_id']
my_id = id_for_member(request.user.email)
party = party_for_member(my_id)
party_id = party.id
rawquery = Member.objects.raw(
"SELECT * FROM api_member WHERE interested_ptr_id=%s AND party_id NOT NULL",
[member_id])
member_is_in_party = len(list(rawquery)) > 0
if member_is_in_party:
return http_response(message="Member is already in a party", code=400)
members = Member.objects.raw(
"SELECT * FROM api_member WHERE party_id NOT NULL AND party_id = %s AND interested_ptr_id = %s",
[party_id, member_id])
if len(list(members)) > 0:
return http_response(message="Member is already part of party")
response = run_connection(
"UPDATE api_member SET party_id = %s WHERE interested_ptr_id = %s",
party_id, member_id)
return response
def join_party(request):
session_email = request.user.username
if not request.user.is_authenticated:
return http_response({}, message="You are not logged in", code=302)
try:
user = Member.objects.get(email=session_email)
except Member.DoesNotExist:
return http_response(
{}, message="You do not have the required permissions", code=403)
member_id = user.id
curr_party_id = user.party_id
if curr_party_id is not None:
return http_response(message="You are already in a party", code=400)
post_dict = dict(request.POST.items())
if not validate_keys(['party_id'], post_dict):
return http_response({}, message="Keys not found", code=400)
party_id = post_dict["party_id"]
return run_connection(
"UPDATE api_member SET party_id=%s WHERE interested_ptr_id=%s",
party_id, member_id)
def settingsAllMembersRouter(request):
"""
Allows boardmembers to get information on all the people in the club (interested, members, boardmembers)
AND promote/demote people
Expect GET OUTPUT dictionary to be of the form
{
'members': [
{
'member_id': _, (Used for promoting/demoting/deletion)
'first_name': _,
'last_name': _,
'email': _,
'status': _ (Interested, Member, BoardMember)
},
...
]
}
Expect POST INPUT dictionary
Example: {"member_id": 39, "status": "Interested"}
Look at POST branch below for specific input dictionaries
:param request:
:return:
"""
if request.method == "GET":
return get_all_club_members()
elif request.method == "POST":
# Promote/demote ONE member (Interested, Member, BoardMember)
# {"member_id": _, "status": _}
# Going to BoardMember, the default 'job'='OFFICER'
post_dict = dict(request.POST)
print(post_dict)
if not validate_keys(["member_id", "status"], post_dict):
return http_response({}, message="Keys not found", code=400)
return update_club_member_status(post_dict)
def create_party(request):
"""
POST -- Creates a party. Anyone with Member permission or above can do this.
Required Keys: queue_type, member_ids
NOTE: member_ids is a comma separated list of ids to add to the party (EXCLUDES the user themselves)
:param request:
:return:
"""
post_dict = dict(request.POST.items())
print(post_dict)
if not validate_keys(['queue_id', 'member_ids'], post_dict):
return http_response({}, message="Keys not found", code=400)
queue_id = post_dict['queue_id']
queues = Queue.objects.raw("SELECT * FROM api_queue WHERE id = %s",
[queue_id])
if len(list(queues)) <= 0:
return http_response(message='Queue does not exist', code=400)
queue = queues[0]
queue_id = queue.id
user_id = id_for_member(request.user.email)
member_ids = post_dict['member_ids']
member_ids = member_ids.split(",") # list of ids to add to the party
if user_id not in member_ids:
member_ids.append(
str(user_id)) # add self to the party, if not already specified
# Check if the user is already in a party
rawquery = Member.objects.raw(
"SELECT * FROM api_member WHERE interested_ptr_id=%s AND party_id NOT NULL",
[user_id])
member_is_in_party = len(list(rawquery)) > 0
if member_is_in_party:
return http_response(message="User is already in a party", code=400)
parties_with_max_id = Party.objects.raw(
"SELECT * FROM api_party WHERE id = (SELECT MAX(id) FROM api_party)")
if len(list(parties_with_max_id)) == 0:
new_id = 0
else:
party_with_max_id = parties_with_max_id[0]
new_id = party_with_max_id.id + 1
# Check if there are other parties on this queue. If not, for each court associated with
# this queue, check if there are matches with NULL endDateTime with the court id. If for a court_id, there
# are no matches with a NULL endDateTime, that means there is no ongoing match on that court. In that case,
# skip creating a party and just throw this group into a match on that empty court.
open_court_id = queue_is_empty_with_open_court(queue_id)
if open_court_id:
# Create match
# Randomize the member_id's into two teams (preferably equal numbers on each team)
a_players = []
b_players = []
num_players = len(member_ids)
for member_id in member_ids:
choice = random.choice([True, False])
if choice and len(a_players) < num_players / 2:
# Add to a_players, if half of players aren't already on there
a_players.append(member_id)
else:
if len(b_players) < num_players / 2:
b_players.append(member_id)
else:
a_players.append(member_id)
create_match(a_players=a_players,
b_players=b_players,
court_id=open_court_id)
return http_response(message="OK", code=200)
else:
# Create party on the queue
response = run_connection(
"INSERT INTO api_party(id, queue_id) VALUES (%s, %s)", new_id,
queue_id)
if response.status_code != 200:
return response
# response = run_connection("UPDATE api_member SET party_id = %s WHERE interested_ptr_id = %s", new_id, member_id)
# if response.status_code != 200:
# return response
add_members_to_party(new_id, member_ids)
return response
