def put(self, stat_id):
data = parser.parse_args()
game_id = data['game_id']
firstClub = data['firstClub']
firstDistance = data['firstDistance']
secondClub = data['secondClub']
secondDistance = data['secondDistance']
stroksGreen = data['stroksGreen']
totalShots = data['totalShots']
total_score = data['totalScore']
try:
# data = parse.parse_args()
stat_id = data['stat_id']
game = GameModel.find_by_id(game_id)
game.total_score = total_score
StatModel.update_stat(stat_id=stat_id,
firstClub=firstClub,
firstDistance=firstDistance,
secondClub=secondClub,
secondDistance=secondDistance,
stroksGreen=stroksGreen,
totalShot=totalShots)
db.session.commit()
return {
'message': 'successfully update a stat {}'.format(stat_id),
'stat_id': stat_id
}
except Exception as e:
print(e)
return {'message': 'something went wrong'}
def game_info():
json = request.get_json()
user = UserStatus.find_user_by_game_name(json['game_name'],json['username'])
if not user:
UserStatus(json['username'],json['game_name']).save_to_db()
game = GameModel.find_by_game_name(json['game_name'])
if game:
return jsonify(game.json())
return jsonify({'message':'Game not found'})
def post(self):
data = parser.parse_args()
print(data)
user_email = get_jwt_identity()
user = UserModel.find_by_email(user_email)
players = data['players']
try:
for player in players:
convert_player = literal_eval(player)
new_player = None
print(convert_player['email'])
new_player = PlayersModel.find_by_email(
convert_player['email'], user.id)
if new_player == None:
print(convert_player)
print(user.id)
new_player = PlayersModel(
user_id=user.id,
email=convert_player['email'],
name=convert_player['name'],
aveScore=convert_player['avgScore'])
print(new_player)
new_player.save_to_db()
new_games = GameModel(course=data['course'],
date=data['date'],
user_id=user.id,
player_id=new_player.id,
total_score=int(data['totalScores'][0]))
new_games.save_to_db()
new_games.game.append(user)
db.session.commit()
return {
'message':
'Course {} was scheduled for {}'.format(
data['course'], data['date']),
'id':
new_games.id
}, 200
except Exception as e:
print(e)
return {'message': 'Something went wrong'}, 500
def get(self):
user_email = get_jwt_identity()
user = UserModel.find_by_email(user_email)
play_game = GameModel.find_by_latest(user.id)
print(play_game)
if play_game:
return {
'game_id': play_game.id,
'date': play_game.date.__str__(),
'course': play_game.course
}
return {'message': 'Something has gone wrong!'}, 500
def post(self):
data = parser.parse_args()
user_email = get_jwt_identity()
user = UserModel.find_by_email(user_email)
hole_id = data['hole_id']
game_id = data['game_id']
found_stat = ScoresModel.find_by_hole_id(hole_id, game_id)
new_game = GameModel.find_by_id(game_id)
if found_stat.stat_id != None:
return {
'message':
'Stat {} is already exists.'.format(found_stat.stat_id)
}, 500
firstClub = data['firstClub']
firstDistance = data['firstDistance']
secondClub = data['secondClub']
secondDistance = data['secondDistance']
stroksGreen = data['stroksGreen']
totalShots = data['totalShots']
totalScore = data['totalScore']
try:
new_stat = StatModel(firstClub=firstClub,
firstDistance=firstDistance,
secondClub=secondClub,
secondDistance=secondDistance,
stroksGreen=stroksGreen,
totalShot=totalShots)
new_stat.save_to_db()
ScoresModel.update_stat_id(user_id=user.id,
game_id=game_id,
hole_id=hole_id,
stat_id=new_stat.id)
new_game.total_score = totalScore
db.session.commit()
return {
'message': 'successfully add hole {}'.format(hole_id),
'stat_id': new_stat.id,
'firstClub': new_stat.first_club,
'firstDistance': new_stat.first_distance,
'secondClub': new_stat.second_club,
'secondDistance': new_stat.second_distance,
'stroksGreen': new_stat.stroks_green,
'totalShots': new_stat.total_shot,
'totalScore': new_game.total_score
}
except Exception as e:
print(e)
return {'message': 'something went wrong'}, 500
def get(self, suffix):
# query for match
match_model = MatchModel.objects(suffix=suffix).first()
match = match_model.as_dict()
# get player data
match_players = [
match_player.as_dict()
for match_player in MatchPlayerModel.objects(
match_id=match['match_id']).order_by('-win')
]
players = []
for match_player in match_players:
player = PlayerModel.objects(
player_id=match_player['player_id']).first().as_dict()
player['backhand'] = BackhandModel.objects(
backhand_id=player['backhand_id']).first().as_dict(
)['backhand']
player.pop('backhand_id', None)
player['country'] = CountryModel.objects(
country_id=player['country_id']).first().as_dict()['country']
player.pop('country_id', None)
player['gender'] = GenderModel.objects(
gender_id=player['gender_id']).first().as_dict()['gender']
player.pop('gender_id', None)
player['hand'] = HandModel.objects(
hand_id=player['hand_id']).first().as_dict()['hand']
player.pop('hand_id', None)
player['score'] = match_player['score']
player['win'] = match_player['win']
players.append(player)
match['players'] = players
# get round data
round_name = RoundModel.objects(
round_id=match['round_id']).first().as_dict()['round_name']
match['round'] = round_name
match.pop('round_id', None)
# get tournament data
tournament = TournamentModel.objects(
tournament_id=match['tournament_id']).first().as_dict()
tournament['gender'] = GenderModel.objects(
gender_id=tournament['gender_id']).first().as_dict()['gender']
tournament.pop('gender_id', None)
tournament['level'] = LevelModel.objects(
level_id=tournament['level_id']).first().as_dict()['level']
tournament.pop('level_id', None)
tournament['surface'] = SurfaceModel.objects(
surface_id=tournament['surface_id']).first().as_dict()['surface']
tournament.pop('surface_id', None)
tournament['tournament_name'] = TournamentNameModel.objects(
tournament_name_id=tournament['tournament_name_id']).first(
).as_dict()['tournament_name']
tournament.pop('tournament_name_id', None)
match['tournament'] = tournament
match.pop('tournament_id', None)
# get set data
match_sets = [
match_set.as_dict() for match_set in SetModel.objects(
match_id=match['match_id']).order_by('set_in_match')
]
set_list = []
for match_set in match_sets:
set_dict = {}
set_dict['set_in_match'] = match_set['set_in_match']
set_dict['players'] = []
match_set_players = [
set_player.as_dict() for set_player in SetPlayerModel.objects(
set_id=match_set['set_id']).order_by('-win')
]
for match_set_player in match_set_players:
match_set_player_dict = {}
match_set_player_dict['full_name'] = [
player['full_name'] for player in players
if player['player_id'] == match_set_player['player_id']
][0]
match_set_player_dict['score'] = match_set_player['score']
match_set_player_dict['win'] = match_set_player['win']
set_dict['players'].append(match_set_player_dict)
# get game data
games = [
game.as_dict() for game in GameModel.objects(
set_id=match_set['set_id']).order_by('game_in_match')
]
game_list = []
for game in games:
game_dict = {}
game_dict['game_in_set'] = game['game_in_set']
game_dict['game_in_match'] = game['game_in_match']
game_dict['players'] = []
game_players = [
game_player.as_dict()
for game_player in GamePlayerModel.objects(
game_id=game['game_id']).order_by('-win')
]
for game_player in game_players:
game_player_dict = {}
game_player_dict['full_name'] = [
player['full_name'] for player in players
if player['player_id'] == game_player['player_id']
][0]
game_player_dict['score'] = game_player['score']
game_player_dict['win'] = game_player['win']
game_dict['players'].append(game_player_dict)
# get point data
points = [
point.as_dict() for point in PointModel.objects(
game_id=game['game_id']).order_by('point_in_match')
]
point_list = []
for point in points:
point_dict = {}
point_dict['point_in_game'] = point['point_in_game']
point_dict['point_in_set'] = point['point_in_set']
point_dict['point_in_match'] = point['point_in_match']
point_dict['side'] = SideModel.objects(
side_id=point['side_id']).first().as_dict()['side']
point_dict.pop('side_id', None)
point_dict['number_of_shots'] = point['number_of_shots']
point_dict['rally_length'] = point['rally_length']
point_dict['result'] = point['result']
point_dict['players'] = []
point_players = [
point_player.as_dict()
for point_player in PointPlayerModel.objects(
point_id=point['point_id']).order_by('-win')
]
for point_player in point_players:
point_player_dict = {}
point_player_dict['full_name'] = [
player['full_name'] for player in players
if player['player_id'] == point_player['player_id']
][0]
point_player_dict['score'] = point_player['score']
point_player_dict['serve'] = point_player['serve']
point_player_dict['win'] = point_player['win']
point_dict['players'].append(point_player_dict)
# get shot data
shots = [
shot.as_dict() for shot in ShotModel.objects(
point_id=point['point_id']).order_by(
'shot_number_w_serve')
]
shot_list = []
for shot in shots:
shot['shot_by'] = [
player['full_name'] for player in players
if player['player_id'] == shot['shot_by']
][0]
shot_list.append(shot)
point_dict['shots'] = shot_list
point_list.append(point_dict)
game_dict['points'] = point_list
game_list.append(game_dict)
set_dict['games'] = game_list
set_list.append(set_dict)
match['sets'] = set_list
return {'match': match}
def getPointData(match_soup, match_id, player_id_dict):
'''
Creates/inserts the appropriate data
'''
# create list of playe names
player_list = [k for k in player_id_dict]
# get dataframe
point_df = makePointDF(match_soup, player_list)
# get list of set numbers
sets_in_match = list(point_df['set_in_match'].unique())
sets_in_match.sort()
# loop through sets_in_match
for set_in_match in sets_in_match:
# filter for set
set_df = point_df.loc[point_df['set_in_match'] == set_in_match]
# get set score by getting last game_score in the set and incrementing winner score
last_point_in_set = set_df.iloc[-1]
server = last_point_in_set['server']
winner = last_point_in_set['winner']
loser = last_point_in_set['loser']
set_score_server = int(last_point_in_set['set_score_server'])
set_score_receiver = int(last_point_in_set['set_score_receiver'])
set_score_winner = set_score_server if winner == server else set_score_receiver
set_score_loser = set_score_server if winner != server else set_score_receiver
# create SetModel
set_model = SetModel(**{'set_in_match': set_in_match, 'match_id': match_id})
set_model.save()
set_id = set_model['set_id']
# create SetPlayerModel
SetPlayerModel(**{'set_id': set_id, 'player_id': player_id_dict[winner], 'win': 1, 'score': set_score_winner}).save()
SetPlayerModel(**{'set_id': set_id, 'player_id': player_id_dict[loser], 'win': 0, 'score': set_score_loser}).save()
# get list of games
games_in_set = list(set_df['game_in_set'].unique())
games_in_set.sort()
# loop through games_in_set
for game_in_set in games_in_set:
# filter for game
game_df = set_df.loc[set_df['game_in_set'] == game_in_set]
# get game score by getting last game_score in the set and incrementing winner score
first_point_in_game = game_df.iloc[0]
server = first_point_in_game['server']
last_point_in_game = game_df.iloc[-1]
game_in_set = last_point_in_game['game_in_set']
game_in_match = last_point_in_game['game_in_match']
winner = last_point_in_game['winner']
loser = last_point_in_game['loser']
game_score_server = last_point_in_game['game_score_server']
game_score_receiver = last_point_in_game['game_score_receiver']
game_score_winner = game_score_server if winner == server else game_score_receiver
game_score_loser = game_score_server if winner != server else game_score_receiver
# create GameModel
game_model = GameModel(**{'set_id': set_id, 'game_in_set': game_in_set, 'game_in_match': game_in_match})
game_model.save()
game_id = game_model['game_id']
# Create GamePlayerModel
GamePlayerModel(**{'game_id': game_id, 'player_id': player_id_dict[winner], 'win': 1, 'serve': (server==winner)*1, 'score': game_score_winner}).save()
GamePlayerModel(**{'game_id': game_id, 'player_id': player_id_dict[loser], 'win': 0, 'serve': (server==loser)*1, 'score': game_score_loser}).save()
# get list of points
points_in_game = list(game_df['point_in_game'].unique())
points_in_game.sort()
# loop through points_in_game
for point_in_game in points_in_game:
# filter for point (should only be one row)
point = game_df.loc[game_df['point_in_game'] == point_in_game].iloc[0]
server = point['server']
receiver = point['receiver']
point_in_set = point['point_in_set']
point_in_match = point['point_in_match']
winner = point['winner']
loser = point['loser']
point_score = point['point_score']
point_score_server = point['point_score_server']
point_score_receiver = point['point_score_receiver']
point_score_winner = point_score_server if winner == server else point_score_receiver
point_score_loser = point_score_server if winner != server else point_score_receiver
serve = (server == winner)*1
number_of_shots = point['number_of_shots']
rally_length = point['rally_length']
rally_split = point['rally_split']
result = point['result']
if result == 'double fault':
rally_length = 0
side = getSide(point_score)
side_id = getSideModel(side)['side_id']
# create PointModel
point_model = PointModel(**{'game_id': game_id, 'point_in_game': point_in_game, 'point_in_set': point_in_set, 'point_in_match': point_in_match, 'number_of_shots': number_of_shots, 'rally_length': rally_length, 'result': result, 'side_id': side_id})
point_model.save()
point_id = point_model['point_id']
# create PointPlayerModel
PointPlayerModel(**{'point_id': point_id, 'player_id': player_id_dict[winner], 'win': 1, 'serve': (server==winner)*1, 'score': point_score_winner}).save()
PointPlayerModel(**{'point_id': point_id, 'player_id': player_id_dict[loser], 'win': 0, 'serve': (server==loser)*1, 'score': point_score_loser}).save()
# get shot data
player_id_list = [player_id_dict[server], player_id_dict[receiver]]
getShotData(rally_split, point_id, player_id_list, result)
return
def makegame():
GameModel("P4Golden").save_to_db()
return jsonify({'message':'New game {} added'.format("P4Golden")})