from django.forms import model_to_dict from django.shortcuts import render from django.db.models import Q from .models import Season, Replayedgame, Teamseason, Playerregister, Reallifeconference # Create your views here. def front_page(request): players = Playerregister.objects.all() context = {'players': players} print(context) return render(request, 'stats/front_page.html', context) def format_playoff_year(year): """Convert '96p' to '1996' and '05p' to '2005' for display purposes.""" if "p" in year: base_year = int(year.replace("p", "")) if base_year >= 96: return f"19{base_year}" else: return f"20{base_year}" return year def standings(request): selected_season = request.GET.get('season') # Fetch available seasons for the dropdown seasons = Season.objects.values('year_code', 'name').distinct() # Fetch all games for the selected season if selected_season: games = Replayedgame.objects.filter(year=selected_season) teams = { t.team_id: {'name': t.name, 'conf_id': t.conf_id} for t in Teamseason.objects.filter(year=selected_season) } conferences = { c.id: c.name for c in Reallifeconference.objects.all() } else: games = Replayedgame.objects.none() teams = {} conferences = {} # Dictionary to hold conference standings standings_by_conference = {} for game in games: for team_id, is_home in [(game.home_id, True), (game.away_id, False)]: team_info = teams.get(team_id, {}) conf_id = team_info.get('conf_id') conf_name = conferences.get(conf_id, "Unknown Conference") if conf_name not in standings_by_conference: standings_by_conference[conf_name] = {} if team_id not in standings_by_conference[conf_name]: standings_by_conference[conf_name][team_id] = { 'team_id': team_id, 'team_name': team_info.get('name', f"Team {team_id}"), 'total': {'wins': 0, 'draws': 0, 'losses': 0, 'points': 0, 'goals_for': 0, 'goals_against': 0, 'goal_diff': 0}, 'home': {'wins': 0, 'draws': 0, 'losses': 0, 'points': 0, 'goals_for': 0, 'goals_against': 0, 'goal_diff': 0}, 'away': {'wins': 0, 'draws': 0, 'losses': 0, 'points': 0, 'goals_for': 0, 'goals_against': 0, 'goal_diff': 0}, } # Assign goals for both home and away teams for team_id, goals_for, goals_against, home_away in [ (game.home_id, game.home_score, game.away_score, 'home'), (game.away_id, game.away_score, game.home_score, 'away') ]: conf_name = conferences.get(teams.get(team_id, {}).get('conf_id'), "Unknown Conference") standings_by_conference[conf_name][team_id]['total']['goals_for'] += goals_for standings_by_conference[conf_name][team_id]['total']['goals_against'] += goals_against standings_by_conference[conf_name][team_id][home_away]['goals_for'] += goals_for standings_by_conference[conf_name][team_id][home_away]['goals_against'] += goals_against # Determine match result home_team_conf = conferences.get(teams.get(game.home_id, {}).get('conf_id'), "Unknown Conference") away_team_conf = conferences.get(teams.get(game.away_id, {}).get('conf_id'), "Unknown Conference") if game.home_score > game.away_score: standings_by_conference[home_team_conf][game.home_id]['total']['wins'] += 1 standings_by_conference[home_team_conf][game.home_id]['total']['points'] += 3 standings_by_conference[home_team_conf][game.home_id]['home']['wins'] += 1 standings_by_conference[home_team_conf][game.home_id]['home']['points'] += 3 standings_by_conference[away_team_conf][game.away_id]['total']['losses'] += 1 standings_by_conference[away_team_conf][game.away_id]['away']['losses'] += 1 elif game.home_score < game.away_score: standings_by_conference[away_team_conf][game.away_id]['total']['wins'] += 1 standings_by_conference[away_team_conf][game.away_id]['total']['points'] += 3 standings_by_conference[away_team_conf][game.away_id]['away']['wins'] += 1 standings_by_conference[away_team_conf][game.away_id]['away']['points'] += 3 standings_by_conference[home_team_conf][game.home_id]['total']['losses'] += 1 standings_by_conference[home_team_conf][game.home_id]['home']['losses'] += 1 else: # Draw standings_by_conference[home_team_conf][game.home_id]['total']['draws'] += 1 standings_by_conference[home_team_conf][game.home_id]['total']['points'] += 1 standings_by_conference[home_team_conf][game.home_id]['home']['draws'] += 1 standings_by_conference[home_team_conf][game.home_id]['home']['points'] += 1 standings_by_conference[away_team_conf][game.away_id]['total']['draws'] += 1 standings_by_conference[away_team_conf][game.away_id]['total']['points'] += 1 standings_by_conference[away_team_conf][game.away_id]['away']['draws'] += 1 standings_by_conference[away_team_conf][game.away_id]['away']['points'] += 1 # Compute goal differentials and sort standings per conference for conf_name, teams in standings_by_conference.items(): for team in teams.values(): team['total']['goal_diff'] = team['total']['goals_for'] - team['total']['goals_against'] team['home']['goal_diff'] = team['home']['goals_for'] - team['home']['goals_against'] team['away']['goal_diff'] = team['away']['goals_for'] - team['away']['goals_against'] team['total']['games_played'] = team['total']['wins'] + team['total']['losses'] + team['total']['draws'] team['home']['games_played'] = team['home']['wins'] + team['home']['losses'] + team['home']['draws'] team['away']['games_played'] = team['away']['wins'] + team['away']['losses'] + team['away']['draws'] team['total']['points_per_game'] = team['total']['points'] / team['total']['games_played'] team['home']['points_per_game'] = team['home']['points'] / team['home']['games_played'] team['away']['points_per_game'] = team['away']['points'] / team['away']['games_played'] standings_by_conference[conf_name] = sorted( teams.values(), key=lambda x: (x['total']['points'], x['total']['wins'], x['total']['goal_diff']), reverse=True ) return render(request, 'stats/standings.html', { 'seasons': seasons, 'selected_season': selected_season, 'standings_by_conference': standings_by_conference }) from django.shortcuts import render, get_object_or_404 from django.db.models import Count, Sum, Avg, Max, Q from .models import ( Teamseason, Replayedgame, Goals, Yellowcard, Redcard, Keepergames, Playerteamseason, Reallifeteam, Playerregister ) def team_detail(request, team_id, season): # Fetch team details team = get_object_or_404(Teamseason, team_id=team_id, year=season) # Fetch team abbreviations team_abbr = {t.id: t.abbrev for t in Reallifeteam.objects.all()} # Fetch replayed games games = Replayedgame.objects.filter(year=season).filter(Q(home_id=team_id) | Q(away_id=team_id)) # Fetch player names all_player_names = {p.player_id: f"{p.firstname} {p.lastname}" for p in Playerregister.objects.all()} # Fetch goal scorers for each game (now includes names) goals_by_game = {} for game in games: goals = Goals.objects.filter(year=season, team_id=team_id, game_id_id=game.id) goals_by_game[game.id] = [ {"player_id": goal.player_id, "player_name": all_player_names.get(goal.player_id, "Unknown"), "minute": goal.minute, "penalty_kick": goal.penalty_kick} for goal in goals ] # Fetch all players from Playerteamseason for this team/season players = Playerteamseason.objects.filter(year=season, team_id=team_id).values_list('register_id', flat=True) # Fetch player names player_names = {p.player_id: f"{p.firstname} {p.lastname}" for p in Playerregister.objects.filter(player_id__in=players)} # Manually aggregate stats player_stats = [] for player_id in players: total_goals = Goals.objects.filter(year=season, player_id=player_id, team_id=team_id).count() penalty_goals = Goals.objects.filter(year=season, player_id=player_id, team_id=team_id, penalty_kick=1).count() total_yellow_cards = Yellowcard.objects.filter(year=season, player_id=player_id, team_id=team_id).count() total_red_cards = Redcard.objects.filter(year=season, player_id=player_id, team_id=team_id).count() player_stats.append({ 'player_id': player_id, # Ensure ID is passed 'player_name': player_names.get(player_id, "Unknown"), 'total_goals': total_goals, 'penalty_goals': penalty_goals, # New field 'total_yellow_cards': total_yellow_cards, 'total_red_cards': total_red_cards, }) # Fetch goalkeeper statistics goalie_stats_raw = Keepergames.objects.filter(year=season, team_id=team_id) # Dictionary to track goalie stats goalie_stats = {} for game in games: # Determine the game result from the perspective of the team if game.home_id == team_id: team_score, opp_score = game.home_score, game.away_score else: team_score, opp_score = game.away_score, game.home_score result = 'draw' if team_score > opp_score: result = 'win' elif team_score < opp_score: result = 'loss' # Get all goalkeepers who played in the game game_goalies = goalie_stats_raw.filter(game_id_id=game.id) if game_goalies.exists(): # Determine the goalie with the most minutes (for win/loss/draw assignment) max_minutes = game_goalies.aggregate(Max('minutes'))['minutes__max'] primary_goalie = game_goalies.filter(minutes=max_minutes).first() # Pick one in case of a tie for goalie in game_goalies: # Ensure this goalie is in the stats dictionary if goalie.player_id not in goalie_stats: goalie_stats[goalie.player_id] = { 'player_id': goalie.player_id, 'player_name': player_names.get(goalie.player_id, "Unknown"), 'total_minutes': 0, 'total_goals_allowed': 0, 'gaa': 0, 'total_wins': 0, 'total_losses': 0, 'total_draws': 0, 'total_shutouts': 0 } # Accumulate minutes and goals allowed goalie_stats[goalie.player_id]['total_minutes'] += goalie.minutes goalie_stats[goalie.player_id]['total_goals_allowed'] += goalie.goals # Assign win/loss/draw only to the goalie who played the most minutes if goalie == primary_goalie: if result == 'win': goalie_stats[goalie.player_id]['total_wins'] += 1 elif result == 'loss': goalie_stats[goalie.player_id]['total_losses'] += 1 else: goalie_stats[goalie.player_id]['total_draws'] += 1 # Count shutouts (if the team allowed 0 goals) if opp_score == 0: goalie_stats[goalie.player_id]['total_shutouts'] += 1 # Calculate Goals Against Average (GAA) for goalie in goalie_stats.values(): if goalie['total_minutes'] > 0: goalie['gaa'] = goalie['total_goals_allowed'] / (goalie['total_minutes'] / 90.0) # Fetch all goalkeepers who played in each game game_goalkeepers = {} for game in games: home_goalies = Keepergames.objects.filter(year=season, game_id_id=game.id, team_id=game.home_id) away_goalies = Keepergames.objects.filter(year=season, game_id_id=game.id, team_id=game.away_id) # Ensure we fetch opponent keepers using the correct team ID home_goalie_list = [ {"player_id": g.player_id, "player_name": all_player_names.get(g.player_id, "Unknown")} for g in home_goalies ] away_goalie_list = [ {"player_id": g.player_id, "player_name": all_player_names.get(g.player_id, "Unknown")} for g in away_goalies ] # Store as lists of dictionaries to maintain player ID references game_goalkeepers[game.id] = { "home": home_goalie_list if home_goalie_list else [{"player_id": None, "player_name": "Unknown"}], "away": away_goalie_list if away_goalie_list else [{"player_id": None, "player_name": "Unknown"}], } # Fetch yellow and red cards for each game yellow_cards_by_game = {} red_cards_by_game = {} for game in games: yellow_cards = Yellowcard.objects.filter(year=season, team_id=team_id, game_id_id=game.id) red_cards = Redcard.objects.filter(year=season, team_id=team_id, game_id_id=game.id) yellow_cards_by_game[game.id] = [ {"player_id": card.player_id, "player_name": all_player_names.get(card.player_id, "Unknown"), "minute": card.minute} for card in yellow_cards ] red_cards_by_game[game.id] = [ {"player_id": card.player_id, "player_name": all_player_names.get(card.player_id, "Unknown"), "minute": card.minute} for card in red_cards ] print(game_goalkeepers) # Pass updated goalkeepers data to template return render(request, 'stats/team_detail.html', { 'team': team, 'season': season, 'games': games, 'goals_by_game': goals_by_game, 'yellow_cards_by_game': yellow_cards_by_game, # New data 'red_cards_by_game': red_cards_by_game, # New data 'player_stats': player_stats, 'goalie_stats': list(goalie_stats.values()), 'team_abbr': team_abbr, 'game_goalkeepers': game_goalkeepers, # Updated with opponent goalkeepers }) from django.shortcuts import render, get_object_or_404 from django.db.models import Sum, Count, Avg, Q from .models import ( Playerregister, Playerteamseason, Keepergames, Goals, Yellowcard, Redcard, Reallifeteam ) def player_detail(request, player_id): # Fetch player details player = get_object_or_404(Playerregister, player_id=player_id) # Format date of birth dob = f"{player.monthofbirth}/{player.dayofbirth}/{player.yearofbirth}" if player.yearofbirth else "Unknown" # Fetch all teams player has played for teams = {team.id: team.abbrev for team in Reallifeteam.objects.all()} # Fetch team-seasons for player team_seasons = Playerteamseason.objects.filter(register_id=player_id) # Fetch goalkeeper stats (if applicable) regular_season_gk_stats = [] playoff_gk_stats = [] total_gk_stats = {"wins": 0, "losses": 0, "draws": 0, "minutes": 0, "goals_allowed": 0, "gaa": 0, "shutouts": 0} # Fetch player stats (including goalkeepers) regular_season_stats = [] playoff_stats = [] total_player_stats = {"goals": 0, "pk_goals": 0, "yellow_cards": 0, "red_cards": 0} # Initialize separate total dictionaries total_regular_gk_stats = {"wins": 0, "losses": 0, "draws": 0, "minutes": 0, "goals_allowed": 0, "gaa": 0, "shutouts": 0} total_playoff_gk_stats = {"wins": 0, "losses": 0, "draws": 0, "minutes": 0, "goals_allowed": 0, "gaa": 0, "shutouts": 0} total_regular_player_stats = {"goals": 0, "pk_goals": 0, "yellow_cards": 0, "red_cards": 0} total_playoff_player_stats = {"goals": 0, "pk_goals": 0, "yellow_cards": 0, "red_cards": 0} # Process goalkeeper stats if player.position and "Goalkeeper" in player.position: keeper_games = Keepergames.objects.filter(player_id=player_id) for year in keeper_games.values_list("year", flat=True).distinct(): season_games = keeper_games.filter(year=year) gk_stats = { "year": format_playoff_year(year), "team": teams.get(season_games.first().team_id, "Unknown"), "wins": season_games.aggregate(Sum("win"))["win__sum"] or 0, "losses": season_games.aggregate(Sum("loss"))["loss__sum"] or 0, "draws": season_games.aggregate(Sum("draw"))["draw__sum"] or 0, "minutes": season_games.aggregate(Sum("minutes"))["minutes__sum"] or 0, "goals_allowed": season_games.aggregate(Sum("goals"))["goals__sum"] or 0, "gaa": 0, # Will be calculated later "shutouts": season_games.filter(minutes__gte=90, goals=0).count(), } if gk_stats["minutes"] > 0: gk_stats["gaa"] = round(gk_stats["goals_allowed"] / (gk_stats["minutes"] / 90.0), 2) if "p" in year: playoff_gk_stats.append(gk_stats) for key in total_playoff_gk_stats: if key != "gaa": total_playoff_gk_stats[key] += gk_stats[key] else: regular_season_gk_stats.append(gk_stats) for key in total_regular_gk_stats: if key != "gaa": total_regular_gk_stats[key] += gk_stats[key] # Compute separate GAA totals if total_regular_gk_stats["minutes"] > 0: total_regular_gk_stats["gaa"] = round(total_regular_gk_stats["goals_allowed"] / (total_regular_gk_stats["minutes"] / 90.0), 2) if total_playoff_gk_stats["minutes"] > 0: total_playoff_gk_stats["gaa"] = round(total_playoff_gk_stats["goals_allowed"] / (total_playoff_gk_stats["minutes"] / 90.0), 2) # Process field player stats for year in team_seasons.values_list("year", flat=True).distinct(): stats = { "year": format_playoff_year(year), "team": teams.get(team_seasons.filter(year=year).first().team_id, "Unknown"), "goals": Goals.objects.filter(player_id=player_id, year=year).count(), "pk_goals": Goals.objects.filter(player_id=player_id, year=year, penalty_kick=1).count(), "yellow_cards": Yellowcard.objects.filter(player_id=player_id, year=year).count(), "red_cards": Redcard.objects.filter(player_id=player_id, year=year).count(), } if "p" in year: playoff_stats.append(stats) for key in total_playoff_player_stats: total_playoff_player_stats[key] += stats[key] else: regular_season_stats.append(stats) for key in total_regular_player_stats: total_regular_player_stats[key] += stats[key] # Pass to template return render(request, "stats/player_detail.html", { "player": player, "dob": dob, "regular_season_gk_stats": regular_season_gk_stats, "playoff_gk_stats": playoff_gk_stats, "total_regular_gk_stats": total_regular_gk_stats, "total_playoff_gk_stats": total_playoff_gk_stats, "regular_season_stats": regular_season_stats, "playoff_stats": playoff_stats, "total_regular_player_stats": total_regular_player_stats, "total_playoff_player_stats": total_playoff_player_stats, }) from django.shortcuts import render from django.db.models import Sum, Count, Avg, Q, F from .models import Playerregister, Goals, Yellowcard, Redcard, Keepergames, Reallifeteam def get_top_players(model, filter_kwargs, group_by_field, count_field, limit=10): """Helper function to get top players in a given category.""" return ( model.objects.filter(**filter_kwargs) .values(group_by_field, "team_id") .annotate(total=Count(count_field)) .order_by("-total")[:limit] ) def get_top_goalkeepers(filter_kwargs, stat_field, limit=10): """Helper function to get top goalkeepers in a given category.""" return ( Keepergames.objects.filter(**filter_kwargs) .values("player_id", "team_id") .annotate(total=Sum(stat_field)) .order_by("-total")[:limit] ) def leaders(request): # Get selected season from request selected_season = request.GET.get("season", None) # Fetch available seasons for dropdown all_seasons = sorted(Goals.objects.values_list("year", flat=True).distinct(), reverse=True) all_seasons.append("Career") # Add Career option # Fetch player names and team abbreviations player_names = {p.player_id: f"{p.firstname} {p.lastname}" for p in Playerregister.objects.all()} team_abbr = {t.id: t.abbrev for t in Reallifeteam.objects.all()} from django.db.models import Value from django.db.models.functions import Concat # Fetch all teams per player for the selected season/career player_teams = ( Playerteamseason.objects.values("register_id", "team_id") ) # Convert to a dictionary for fast lookup in the template player_teams_dict = {} for entry in player_teams: player_id = str(entry["register_id"]) # Ensure consistent string type team_name = team_abbr.get(entry["team_id"], "Unknown") if player_id in player_teams_dict: player_teams_dict[player_id].append(team_name) else: player_teams_dict[player_id] = [team_name] import pprint # Debug: Print the dictionary in a readable format pp = pprint.PrettyPrinter(indent=2) pp.pprint(player_teams_dict) # Format teams as "Team1 / Team2" for player_id, teams in player_teams_dict.items(): player_teams_dict[player_id] = " / ".join(sorted(set(teams))) # Remove duplicates and sort print(player_teams_dict[player_id]) if selected_season == "Career": filter_kwargs = {} else: filter_kwargs = {"year": selected_season} if selected_season else {"year": all_seasons[0]} # Fetch leaders for the selected season or career leaders_data = { "goals": get_top_players(Goals, filter_kwargs, "player_id", "id"), "pk_goals": get_top_players(Goals, {**filter_kwargs, "penalty_kick": 1}, "player_id", "id"), "yellow_cards": get_top_players(Yellowcard, filter_kwargs, "player_id", "id"), "red_cards": get_top_players(Redcard, filter_kwargs, "player_id", "id"), "gk_wins": get_top_goalkeepers(filter_kwargs, "win"), "gk_draws": get_top_goalkeepers(filter_kwargs, "draw"), "gk_losses": get_top_goalkeepers(filter_kwargs, "loss"), "gk_points": get_top_goalkeepers(filter_kwargs, F("win") * 3 + F("draw") * 1), "most_goals_allowed": get_top_goalkeepers(filter_kwargs, "goals"), "most_shutouts": ( Keepergames.objects.filter(**filter_kwargs, minutes__gte=90, goals=0) .values("player_id", "team_id") .annotate(total=Count("game_id_id", distinct=True)) # Count distinct games, not total rows .order_by("-total")[:10] ), "lowest_gaa": ( Keepergames.objects.filter(**filter_kwargs) # Includes all seasons if career .values("player_id") # Group only by player, not team .annotate( total_minutes=Sum("minutes"), # Aggregate total minutes across all teams/seasons total_goals_allowed=Sum("goals"), # Aggregate total goals allowed across all teams/seasons ) .filter(total_minutes__gte=720) # Apply 720-minute threshold AFTER aggregation .annotate( gaa=F("total_goals_allowed") / (F("total_minutes") / 90.0) # Correct GAA calculation ) .order_by("gaa")[:10] # Order by lowest GAA ), } return render(request, "stats/leaders.html", { "selected_season": selected_season if selected_season else all_seasons[0], "all_seasons": all_seasons, "leaders_data": leaders_data, "player_names": player_names, "team_abbr": team_abbr, "player_teams_dict": player_teams_dict }) from django.shortcuts import render, get_object_or_404 from .models import Replayedgame, Goals, Yellowcard, Redcard, Keepergames, Reallifeteam, Playerregister def game_detail(request, game_id): game = get_object_or_404(Replayedgame, id=game_id) home_team = Reallifeteam.objects.get(id=game.home_id) away_team = Reallifeteam.objects.get(id=game.away_id) home_goals = Goals.objects.filter(year=game.year, game_id_id=game_id, team_id=game.home_id) away_goals = Goals.objects.filter(year=game.year, game_id_id=game_id, team_id=game.away_id) home_yellows = Yellowcard.objects.filter(year=game.year, game_id_id=game_id, team_id=game.home_id) away_yellows = Yellowcard.objects.filter(year=game.year, game_id_id=game_id, team_id=game.away_id) home_reds = Redcard.objects.filter(year=game.year, game_id_id=game_id, team_id=game.home_id) away_reds = Redcard.objects.filter(year=game.year, game_id_id=game_id, team_id=game.away_id) home_goalies = Keepergames.objects.filter(year=game.year, game_id_id=game_id, team_id=game.home_id) away_goalies = Keepergames.objects.filter(year=game.year, game_id_id=game_id, team_id=game.away_id) player_cache = {p.player_id: f"{p.firstname} {p.lastname}" for p in Playerregister.objects.all()} events = [] def add_event(queryset, team_label, event_type): for item in queryset: events.append({ "minute": item.minute, "player_name": player_cache.get(item.player_id, 'Unknown'), "player_id": item.player_id, "team": team_label, "type": event_type, "penalty_kick": getattr(item, 'penalty_kick', 0) }) add_event(home_goals, 'home', 'goal') add_event(away_goals, 'away', 'goal') add_event(home_yellows, 'home', 'yellow') add_event(away_yellows, 'away', 'yellow') add_event(home_reds, 'home', 'red') add_event(away_reds, 'away', 'red') events.sort(key=lambda e: e['minute']) # home_goalkeeper_names = ', '.join([player_cache.get(g.player_id, 'Unknown') for g in home_goalies]) # away_goalkeeper_names = ', '.join([player_cache.get(g.player_id, 'Unknown') for g in away_goalies]) home_goalkeepers = [ {"player_id": g.player_id, "player_name": player_cache.get(g.player_id, 'Unknown')} for g in home_goalies ] away_goalkeepers = [ {"player_id": g.player_id, "player_name": player_cache.get(g.player_id, 'Unknown')} for g in away_goalies ] context = { "game": game, "home_team": home_team, "away_team": away_team, "events": events, "home_goalkeepers": home_goalkeepers, "away_goalkeepers": away_goalkeepers, } print(context) return render(request, "stats/game_detail.html", context) from django.shortcuts import render, redirect from django.http import JsonResponse from .models import Replayedgame, Goals, Keepergames, Yellowcard, Redcard, Regulationpenalty def save_stats(request): if request.method == "POST": season = request.POST.get("season") game_date = request.POST.get("game_date") home_team = request.POST.get("home_team") away_team = request.POST.get("away_team") final_home_score = request.POST.get("final_home_score", 0) final_away_score = request.POST.get("final_away_score", 0) # Create or update the game record game, created = Replayedgame.objects.update_or_create( year=season, home_id=home_team, away_id=away_team, defaults={"home_score": final_home_score, "away_score": final_away_score, "date": game_date} ) # Process Goalkeepers for team, player, minutes, goals_allowed in zip( request.POST.getlist("keeper_team[]"), request.POST.getlist("keeper_player[]"), request.POST.getlist("keeper_minutes[]"), request.POST.getlist("keeper_goals_allowed[]")): Keepergames.objects.create( game_id=game.id, team_id=team, player_id=player, minutes=int(minutes), goals=int(goals_allowed), year=season ) # Process Goals for minute, team, scorer, penalty in zip( request.POST.getlist("goal_minute[]"), request.POST.getlist("goal_team[]"), request.POST.getlist("goal_scorer[]"), request.POST.getlist("goal_penalty[]")): Goals.objects.create( game_id=game.id, minute=int(minute), team_id=team, player_id=scorer, penalty_kick=int(penalty), year=season ) # Process Penalties for minute, team, scorer, scored in zip( request.POST.getlist("penalty_minute[]"), request.POST.getlist("penalty_team[]"), request.POST.getlist("penalty_scorer[]"), request.POST.getlist("penalty_scored[]")): Regulationpenalty.objects.create( game_id=game.id, minute=int(minute), team_id=team, player_id=scorer, goal=int(scored), year=season ) # Process Yellow Cards for minute, team, player in zip( request.POST.getlist("yellow_minute[]"), request.POST.getlist("yellow_team[]"), request.POST.getlist("yellow_player[]")): Yellowcard.objects.create( game_id=game.id, minute=int(minute), team_id=team, player_id=player, year=season ) # Process Red Cards for minute, team, player in zip( request.POST.getlist("red_minute[]"), request.POST.getlist("red_team[]"), request.POST.getlist("red_player[]")): Redcard.objects.create( game_id=game.id, minute=int(minute), team_id=team, player_id=player, year=season ) return JsonResponse({"status": "success", "game_id": game.id}) return JsonResponse({"status": "error", "message": "Invalid request"}, status=400) from django.http import JsonResponse from .models import Playerregister def get_players_by_team(request, team_id): players = Playerregister.objects.filter(team_id=team_id).values("player_id", "firstname", "lastname") players_list = [{"id": p["player_id"], "name": f"{p['firstname']} {p['lastname']}"} for p in players] return JsonResponse({"players": players_list}) def record_game_stats(request): return render(request, "stats/updated_frontend.html", {"seasons": Season.objects.all()}) import json from django.http import JsonResponse from django.db import connection from django.views.decorators.csrf import csrf_exempt @csrf_exempt # Only use this if handling CSRF manually in the frontend def process_queries(request): if request.method == "POST": try: data = json.loads(request.body) queries = [ data.get("game"), data.get("keepers"), data.get("goals"), data.get("yellow_cards"), data.get("red_cards"), data.get("penalties"), ] with connection.cursor() as cursor: for query in queries: if query: # Ensure the query is not empty cursor.execute(query) return JsonResponse({"status": "success"}) except Exception as e: return JsonResponse({"status": "error", "message": str(e)}, status=400) return JsonResponse({"status": "error", "message": "Invalid request"}, status=400)