def put(self):
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.user_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('userID')
parser.add_argument('userType')
parser.add_argument('firstName')
parser.add_argument('lastName')
parser.add_argument('email')
args = parser.parse_args()
user_id = args['userID']
user_type = args['userType']
first_name = args['firstName']
last_name = args['lastName']
email = args['email']
privilege_id = None
if user_type == 'Admin':
privilege_id = 1
elif user_type == 'Coordinator':
privilege_id = 2
elif user_type == 'Manager':
privilege_id = 3
elif user_type == 'Referee':
privilege_id = 4
# using update_user stored procedure to update user
db_connector = DatabaseConnector()
db_connector.cursor.callproc(
'update_user',
[user_id, privilege_id, user_type, first_name, last_name, email])
db_connector.conn.commit()
# getting user_id to return to the frontend
db_connector.cursor.execute('CALL get_user("{}");'.format(email))
db_response = db_connector.cursor.fetchone()
user_data = {
'user_id':
db_response[0],
'user_type':
db_response[2],
'first_name':
db_response[3],
'last_name':
db_response[4],
'email':
db_response[5],
'last_login':
db_response[7].strftime('%Y-%m-%d %H:%M:%S')
if db_response[7] else None
}
db_connector.conn.close()
return {'user': user_data}, 200
def delete(self):
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.assign_privileges(
): # I'm using this as a placeholder for a general admin privilege
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('leagueID', type=int)
args = parser.parse_args()
target_league_id = args['leagueID']
db = DatabaseConnector()
db.cursor.execute(
"DELETE FROM gameMembers WHERE teamID in (SELECT teamID FROM teams WHERE leagueID = %d);"
% target_league_id)
db.cursor.execute("DELETE FROM games WHERE leagueID = %d;" %
target_league_id)
db.cursor.execute(
"DELETE FROM players WHERE teamID in (SELECT teamID FROM teams WHERE leagueID = %d);"
% target_league_id)
db.cursor.execute("DELETE FROM teams WHERE leagueID = %d;" %
target_league_id)
db.cursor.execute("DELETE FROM leagues WHERE leagueID = %d;" %
target_league_id)
db.conn.commit()
return 200
def post(self):
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.game_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
db = DatabaseConnector()
# 1. generate play order for teams in league
# 2. match play order with field/time pairs given by client
# 3. generate db data
# EXPECTED DATA
# {leagueID: 1,
# games: [ {gameTime: "2000-12-12 06:00:00", (formatted datetime str)
# field: "FieldA",
# refereeID: 1} (TODO will likely need to implement some sort of referee lookup to handle this data
# ]}
data = request.get_json(force=True)
print(data)
leagueid = data["leagueID"]
db.cursor.execute('SELECT * FROM teams WHERE leagueID = ' +
str(leagueid))
teams = db.cursor.fetchall()
datelist = []
teamlist = []
for t in teams:
teamlist.append(t[0])
for g in data['games']:
datetime = g["gameTime"]
field = g["field"]
ref = g['refereeID']
datelist.append((datetime, field, ref))
matchlist = Scheduler.create_matches(teamlist)
print(matchlist)
scheduleGenerator = newScheduler.findNextValid(matchlist, datelist)
schedule = []
for i in range(0, len(datelist)):
schedule.append(next(scheduleGenerator))
for s in schedule:
homeID = s[0][0]
awayID = s[0][1]
gameTime = s[1][0]
field = s[1][1]
query = 'INSERT INTO games (leagueID, homeTeamID, awayTeamID, gameTime, field) VALUES (%d, %d, %d, \'%s\', \'%s\');' % (
leagueid, homeID, awayID, gameTime, field)
print(query)
db.cursor.execute(query=query)
return schedule, 200
def post(self):
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.schedule_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('leagueID', type=int, required=True)
parser.add_argument('homeTeamID', type=int, required=True)
parser.add_argument('awayTeamID', type=int, required=True)
parser.add_argument('refereeID', type=int)
parser.add_argument('gameTime', type=str)
parser.add_argument('fieldName', type=str)
parser.add_argument('status', type=str)
args = parser.parse_args()
league_id = args['leagueID']
home_team_id = args['homeTeamID']
away_team_id = args['awayTeamID']
referee_id = args['refereeID']
game_time = args['gameTime']
field_name = args['fieldName']
status = args['status']
db = DatabaseConnector()
db.cursor.callproc('create_game', [
league_id, home_team_id, away_team_id, referee_id, game_time,
field_name, status
])
db.conn.commit()
db.cursor.close()
game_data = {
'leagueName': league_id,
'homeTeamID': home_team_id,
'awayTeamID': away_team_id,
'refereeID': referee_id,
'gameTime': game_time,
'fieldName': field_name,
'status': status,
}
return {'game': game_data}, 201
def put(self):
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.player_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('playerID', type=int)
parser.add_argument('teamID', type=int)
parser.add_argument('firstName', type=str)
parser.add_argument('lastName', type=str)
parser.add_argument('email', type=str)
parser.add_argument('number', type=int)
args = parser.parse_args()
player_id = args['playerID']
team_id = args['teamID']
first_name = args['firstName']
last_name = args['lastName']
email = args['email'] if args['email'] else None
number = args['number']
db_connector = DatabaseConnector()
db_connector.cursor.callproc(
'update_player',
[player_id, team_id, first_name, last_name, email, number])
db_connector.conn.commit()
db_connector.conn.close()
player = {
'playerID': player_id,
'teamID': team_id,
'firstName': first_name,
'lastName': last_name,
'email': email,
'number': number
}
return {'player': player}, 200
def delete(self):
"""
Deletes a team from the database.
:Input: ID of the team to delete.
.. code-block:: javascript
{
'teamID': Integer
}
Possible status codes: 403 = No permissions, 200 = Successfully deleted.
"""
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.team_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('teamID')
args = parser.parse_args()
team_id = args['teamID']
# deleting team object
db_connector = DatabaseConnector()
try:
db_connector.cursor.execute('DELETE FROM teams WHERE teamID = {}'.format(team_id))
db_connector.conn.commit()
except Exception as e:
abort(401, error='Invalid delete: {}'.format(e))
finally:
db_connector.conn.close()
return 200
def delete(self):
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.user_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('userID')
args = parser.parse_args()
user_id = args['userID']
# deleting user object
db_connector = DatabaseConnector()
db_connector.cursor.execute(
'DELETE FROM users WHERE userID = {}'.format(user_id))
db_connector.conn.commit()
db_connector.conn.close()
return
def delete(self, game_id):
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.league_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
player_id = request.args.get("player_id")
# creating new league in the database
db_connector = DatabaseConnector()
try:
db_connector.cursor.callproc('delete_game_member',
[int(game_id), player_id])
except Exception as e:
abort(400, error=str(e))
db_connector.conn.commit()
db_connector.cursor.close()
return 'gameMember (' + str(game_id) + ", " + str(
player_id) + ") has been deleted", 200
def delete(self):
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.schedule_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('leagueID', type=int, required=True)
args = parser.parse_args()
query = "SELECT gameID from gameMembers WHERE gameID in (SELECT gameID from games where leagueID = %s)" % args[
'leagueID']
db = DatabaseConnector()
db.cursor.execute(query)
res = db.cursor.fetchall()
if res:
return 400, "Cannot delete schedule were games have been recorded"
else:
query = "DELETE FROM games WHERE leagueID = %s" % args['leagueID']
db.cursor.execute(query)
db.conn.commit()
return 200
def put(self):
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.league_privileges(
): # I'm using this as a placeholder for a general admin privilege
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('leagueID', type=int, required=True)
parser.add_argument('managerID', type=int)
parser.add_argument('leagueName', type=str)
parser.add_argument('season', type=str)
parser.add_argument('pointScheme', type=str)
args = parser.parse_args()
query = "UPDATE leagues SET coordinatorID = %d, leagueName = '%s', season = '%s', pointScheme = '%s' WHERE leagueID = %d" \
% (args['managerID'], args['leagueName'], args['season'], args['pointScheme'], args['leagueID'])
db = DatabaseConnector()
db.cursor.execute(query)
db.conn.commit()
return 200
def delete(self):
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.player_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('playerID')
args = parser.parse_args()
player_id = args['playerID']
db_connector = DatabaseConnector()
try:
db_connector.cursor.execute(
'DELETE FROM players WHERE playerID = {}'.format(player_id))
db_connector.conn.commit()
db_connector.conn.close()
except Exception as e:
db_connector.conn.close()
abort(400, error='Invalid delete {}'.format(e))
return
def put(self):
"""
Updates a team object in the database.
:Input: Team JSON object with new data.
.. code-block:: javascript
{
'teamID': Integer,
'leagueID': Integer,
'managerID': Integer,
'teamName': String,
'colour': String (Hex Colour Code),
'leaguePoints': Integer,
'wins': Integer,
'losses': Integer,
'draws': Integer
}
:return: The updated team JSON object
.. code-block:: javascript
{
'teamID': Integer,
'leagueID': Integer,
'managerID': Integer,
'teamName': String,
'colour': String (Hex Colour Code),
'leaguePoints': Integer,
'wins': Integer,
'losses': Integer,
'draws': Integer
}
Possible status codes: 403 = No permissions, 200 = Successfully updated.
"""
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.team_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('teamID', type=int)
parser.add_argument('leagueID', type=int)
parser.add_argument('managerID', type=int)
parser.add_argument('teamName', type=str)
parser.add_argument('colour', type=str)
parser.add_argument('leaguePoints', type=str)
parser.add_argument('wins', type=str)
parser.add_argument('losses', type=str)
parser.add_argument('draws', type=str)
args = parser.parse_args()
team_id = args['teamID']
league_id = args['leagueID']
manager_id = args['managerID']
team_name = args['teamName']
colour = args['colour']
league_points = args['leaguePoints']
wins = args['wins']
losses = args['losses']
draws = args['draws']
# using update_team stored procedure to update team
db_connector = DatabaseConnector()
db_connector.cursor.callproc('update_team',
[team_id,
league_id,
manager_id,
team_name,
colour,
league_points,
wins,
losses,
draws])
db_connector.conn.commit()
# getting team_id to return to the frontend
db_connector.cursor.callproc('get_team', [team_id])
db_response = db_connector.cursor.fetchone()
team_data = {
'teamID': db_response[0],
'leagueID': db_response[1],
'managerID': db_response[2],
'teamName': db_response[3],
'colour': db_response[4],
'leaguePoints': db_response[5],
'wins': db_response[6],
'losses': db_response[7],
'draws': db_response[8]
}
db_connector.conn.close()
return team_data, 200
def post(self, game_id):
"""
Adds a roster to the database.
:Input: JSON object representing the game-roster
.. code-block:: javascript
roster: List<Player> {
"playerID": int,
"teamID": int,
"number": int,
"goals": int,
"cleanSheet": int,
"yellowCards": int,
"redCards": int
}
Success gives status code 201
"""
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.assign_player():
abort(403, error="Unauthorized Access (invalid permissions)")
roster = request.get_json()['roster']
# creating new league in the database
db_connector = DatabaseConnector()
db_connector.cursor.callproc('get_game_team_lineup', [int(game_id)])
team_lineup = db_connector.cursor.fetchall()[0]
conflicts = []
count = 0
for player in roster:
player_id = player['playerID']
team_id = player['teamID']
number = player['number']
if team_id != team_lineup[0] and team_id != team_lineup[1]:
conflicts.append("Team " + str(team_id) +
" is not playing in game " + str(game_id))
else:
try:
db_connector.cursor.callproc(
'create_game_member',
[int(game_id), player_id, team_id, number, 0, 0, 0, 0])
except Exception as e:
conflicts.append(str(e))
count += 1
db_connector.conn.commit()
db_connector.cursor.close()
return {'conflicts': conflicts}, 201
def get(self):
"""
Gets user data from the database.
:Input:
.. code-block:: javascript
Header:
'Authorization': String (JSON Web Token)
:return: A JSON object containing the user data.
.. code-block:: javascript
{
'userID': Integer,
'userType': String,
'firstName': String,
'lastName': String,
'email': String,
'lastLogin': String
}
Success gives status code 200
"""
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
tk_handler = TokenHandler()
user_email = tk_handler.decode_token(token)
db_connector = DatabaseConnector()
# getting user_id to return to the frontend
db_connector.cursor.execute('CALL get_user("{}");'.format(user_email))
db_response = db_connector.cursor.fetchone()
user_data = {
'userID':
db_response[0],
'userType':
db_response[2],
'firstName':
db_response[3],
'lastName':
db_response[4],
'email':
db_response[5],
'lastLogin':
db_response[7].strftime('%Y-%m-%d %H:%M:%S')
if db_response[7] else None
}
# returning data for all users if the user has user modification privileges
privilege_handler = PrivilegeHandler(token)
payload = {'user': user_data}
if privilege_handler.user_privileges():
db_connector.cursor.execute('SELECT * FROM users')
users = db_connector.cursor.fetchall()
users_data = []
for user in users:
users_data.append({
'userID':
user[0],
'privilegeID':
user[1],
'userType':
user[2],
'firstName':
user[3],
'lastName':
user[4],
'email':
user[5],
'lastLogin':
user[7].strftime('%Y-%m-%d %H:%M:%S') if user[7] else None
})
payload['users'] = users_data
db_connector.conn.close()
return payload, 200
def post(self):
"""
Adds a new league to the database.
.. todo::
Privileges associated with token
.. code-block:: python
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
:Input: JSON object representing the league
.. code-block:: javascript
{
'leagueName': String,
'season': String
}
:return: The league object that was created
.. code-block:: javascript
{
'leagueName': String,
'season': String
}
Success gives status code 201
"""
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.league_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('leagueName', type=str)
parser.add_argument('season', type=str)
parser.add_argument('pointScheme', type=str)
args = parser.parse_args()
league_name = args['leagueName']
season = args['season']
point_scheme = args['pointScheme']
# creating new league in the database
db_connector = DatabaseConnector()
db_connector.cursor.callproc('create_league',
[league_name, season, point_scheme])
db_connector.conn.commit()
db_connector.cursor.close()
league_data = {
'leagueName': league_name,
'season': season,
'pointScheme': point_scheme
}
return {'league': league_data}, 201
def post(self):
"""
Adds a new team to the database.
:Input: JSON object representing the team
.. code-block:: javascript
{
'teamName': String,
'leagueID': Integer,
'colour': String (Hex Colour Code)
}
:return: The team object that was created
.. code-block:: javascript
{
'teamName': String,
'leagueID': Integer,
'colour': String (Hex Colour Code)
}
Possible status codes: 403 = No permissions, 201 = Successfully added.
"""
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.team_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('teamName', type=str)
parser.add_argument('leagueID', type=int)
parser.add_argument('colour', type=str)
args = parser.parse_args()
team_name = args['teamName']
league_id = args['leagueID']
colour = args['colour']
# creating new league in the database
db_connector = DatabaseConnector()
db_connector.cursor.callproc('create_team', [team_name, league_id, colour])
db_connector.conn.commit()
db_connector.cursor.close()
team_data = {
'teamName': team_name,
'leagueID': league_id,
'colour': colour
}
return {'team': team_data}, 201
def post(self):
"""
Adds a new player to the database.
:Input: JSON object representing the player
.. code-block:: javascript
{
'teamID': Integer,
'firstName': String,
'lastName': String,
'email': String (optional),
'number': Integer (optional)
}
:return: The player object that was created
.. code-block:: javascript
{
'teamID': Integer,
'firstName': String,
'lastName': String,
'email': String,
'number': Integer
}
Success gives status code 201
"""
token = request.headers.get('Authorization')
if not token:
abort(403, error="Unauthorized Access (no token)")
privilege_handler = PrivilegeHandler(token)
if not privilege_handler.player_privileges():
abort(403, error="Unauthorized Access (invalid permissions)")
parser = reqparse.RequestParser()
parser.add_argument('teamID', type=int)
parser.add_argument('firstName', type=str)
parser.add_argument('lastName', type=str)
parser.add_argument('email', type=str)
parser.add_argument('number', type=int)
args = parser.parse_args()
team_id = args['teamID']
first_name = args['firstName']
last_name = args['lastName']
email = args['email'] if args['email'] else None
number = args['number']
db_connector = DatabaseConnector()
db_connector.cursor.callproc(
'create_player', [team_id, first_name, last_name, email, number])
db_connector.conn.commit()
db_connector.conn.close()
player = {
'teamID': team_id,
'firstName': first_name,
'lastName': last_name,
'email': email,
'number': number
}
return {'player': player}, 201
