You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
301 lines
10 KiB
301 lines
10 KiB
from django.db import models
|
|
from tournaments.models import group_stage
|
|
from . import Round, GroupStage, FederalMatchCategory
|
|
from django.utils import timezone, formats
|
|
from datetime import datetime, timedelta
|
|
|
|
import uuid
|
|
|
|
from ..utils.extensions import format_seconds
|
|
|
|
class Match(models.Model):
|
|
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=True)
|
|
round = models.ForeignKey(Round, null=True, blank=True, on_delete=models.CASCADE)
|
|
group_stage = models.ForeignKey(GroupStage, null=True, blank=True, on_delete=models.CASCADE)
|
|
name = models.CharField(max_length=200, null=True, blank=True)
|
|
start_date = models.DateTimeField(null=True, blank=True)
|
|
end_date = models.DateTimeField(null=True, blank=True)
|
|
index = models.IntegerField(default=0)
|
|
#order = models.IntegerField(default=0)
|
|
format = models.IntegerField(default=FederalMatchCategory.NINE_GAMES, choices=FederalMatchCategory.choices, null=True, blank=True)
|
|
#court = models.CharField(max_length=50, null=True, blank=True)
|
|
serving_team_id = models.UUIDField(null=True, blank=True)
|
|
winning_team_id = models.UUIDField(null=True, blank=True)
|
|
losing_team_id = models.UUIDField(null=True, blank=True)
|
|
#broadcasted = models.BooleanField(default=False)
|
|
disabled = models.BooleanField(default=False)
|
|
court_index = models.IntegerField(null=True, blank=True)
|
|
confirmed = models.BooleanField(default=False)
|
|
|
|
def __str__(self):
|
|
names = " / ".join(self.player_names())
|
|
return f"{self.stage_name()} #{self.index}: {names}"
|
|
|
|
def tournament(self):
|
|
if self.round:
|
|
return self.round.tournament
|
|
else:
|
|
return self.group_stage.tournament
|
|
|
|
def court_name(self, index):
|
|
club = None
|
|
if self.tournament().event:
|
|
club = self.tournament().event.club
|
|
|
|
if club:
|
|
return club.court_name(index)
|
|
elif index is not None:
|
|
return f"Terrain {index + 1}"
|
|
return ""
|
|
|
|
def backup_name(self):
|
|
items = []
|
|
if self.round:
|
|
items.append(self.round.name())
|
|
items.append(f" #{self.index}")
|
|
elif self.group_stage:
|
|
items.append(self.group_stage.name())
|
|
items.append(f"Match #{self.index}")
|
|
return " ".join(items)
|
|
|
|
def summon_stage_name(self):
|
|
if self.round:
|
|
return self.round.name()
|
|
elif self.group_stage:
|
|
return "Poule"
|
|
else:
|
|
return '--'
|
|
|
|
def stage_name(self):
|
|
if self.name:
|
|
return self.name
|
|
elif self.round:
|
|
return self.round.name()
|
|
elif self.group_stage:
|
|
return self.group_stage.display_name()
|
|
else:
|
|
return '--'
|
|
|
|
def player_names(self):
|
|
return map(lambda ts: ts.player_names(), self.team_scores.all())
|
|
|
|
def local_start_date(self):
|
|
timezone = self.tournament().timezone()
|
|
return self.start_date.astimezone(timezone)
|
|
|
|
def formatted_start_date(self):
|
|
if self.start_date:
|
|
local_start = self.local_start_date()
|
|
return formats.date_format(local_start, format='H:i')
|
|
else:
|
|
return ''
|
|
|
|
def time_indication(self):
|
|
if self.end_date:
|
|
if self.start_date:
|
|
return self.magic_duration()
|
|
else:
|
|
return ''
|
|
elif self.start_date:
|
|
if self.started():
|
|
return self.formatted_duration()
|
|
else:
|
|
# timezoned_datetime = timezone.localtime(self.start_date)
|
|
timezone = self.tournament().timezone()
|
|
local_start = self.start_date.astimezone(timezone)
|
|
return formats.date_format(local_start, format='l H:i')
|
|
else:
|
|
return 'À venir...'
|
|
|
|
def magic_duration(self):
|
|
seconds = (self.end_date - self.start_date).total_seconds()
|
|
average_duration = self.average_seconds_duration()
|
|
|
|
if (average_duration / 2) > seconds or seconds > (average_duration * 2):
|
|
seconds = average_duration
|
|
|
|
return format_seconds(seconds)
|
|
|
|
def average_seconds_duration(self):
|
|
return 3 * 60 * self.total_number_of_games()
|
|
|
|
def total_number_of_games(self):
|
|
games = 0.0
|
|
for team_score in self.team_scores.all():
|
|
games += team_score.estimated_number_of_games()
|
|
return games
|
|
|
|
def current_duration(self):
|
|
if self.confirmed and self.start_date:
|
|
if self.end_date:
|
|
return (self.end_date - self.start_date).total_seconds()
|
|
else:
|
|
current = (timezone.now() - self.start_date).total_seconds()
|
|
if self.total_number_of_games() > 0 and current < self.average_seconds_duration() * 4:
|
|
return current
|
|
elif self.total_number_of_games() == 0 and current < 3 * 60 * 60:
|
|
return current
|
|
else:
|
|
return None
|
|
# print(current)
|
|
# print(self.average_seconds_duration())
|
|
# print('*******')
|
|
# if current < self.average_seconds_duration() * 4:
|
|
# return current
|
|
# else:
|
|
# return None
|
|
# return (timezone.now() - self.start_date).total_seconds()
|
|
else:
|
|
return None
|
|
|
|
def started(self):
|
|
if self.confirmed:
|
|
if self.end_date:
|
|
return True
|
|
elif self.start_date:
|
|
return timezone.now() > self.start_date
|
|
return False
|
|
|
|
def should_appear(self):
|
|
if self.disabled is True:
|
|
return False
|
|
return len(self.team_scores.all()) > 0
|
|
|
|
# elif self.group_stage is None:
|
|
# if len(self.team_scores.all()) == 2:
|
|
# return True
|
|
# else:
|
|
# return (self.start_date or self.end_date) and len(self.team_scores.all()) > 0
|
|
# else:
|
|
# return len(self.team_scores.all()) > 0
|
|
|
|
def formatted_duration(self):
|
|
|
|
seconds = self.current_duration()
|
|
if seconds is None:
|
|
return ''
|
|
|
|
if seconds > 0:
|
|
return format_seconds(seconds)
|
|
# _hours = int(_seconds / 3600)
|
|
# _minutes = int((_seconds % 3600) / 60)
|
|
# return f"{_hours:02d}h{_minutes:02d}min"
|
|
else :
|
|
seconds = seconds * -1
|
|
return format_seconds(seconds)
|
|
# _hours = int(_seconds / 3600)
|
|
# _minutes = int((_seconds % 3600) / 60)
|
|
# return f"{_hours:02d}h{_minutes:02d}min"
|
|
|
|
def live_match(self):
|
|
title = self.name if self.name else self.backup_name()
|
|
date = self.formatted_start_date()
|
|
time_indication = self.time_indication()
|
|
court = self.court_name(self.court_index)
|
|
group_stage_name = None
|
|
if self.group_stage:
|
|
group_stage_name = self.group_stage.display_name()
|
|
|
|
ended = self.end_date is not None
|
|
livematch = LiveMatch(title, date, time_indication, court, self.started(), ended, group_stage_name)
|
|
|
|
for team_score in self.sorted_team_scores():
|
|
if team_score.team_registration:
|
|
image = team_score.team_registration.logo
|
|
weight = team_score.team_registration.weight
|
|
is_winner = team_score.team_registration.id == self.winning_team_id
|
|
else:
|
|
image = None
|
|
weight= None
|
|
is_winner = False
|
|
names = team_score.shortened_team_names()
|
|
scores = team_score.scores_array()
|
|
walk_out = team_score.walk_out
|
|
team = Team(image, names, scores, weight, is_winner, walk_out)
|
|
livematch.add_team(team)
|
|
|
|
return livematch
|
|
|
|
def sorted_team_scores(self):
|
|
if self.group_stage:
|
|
return self.team_scores.order_by('team_registration__group_stage_position')
|
|
else:
|
|
return self.team_scores.order_by('team_registration__bracket_position')
|
|
|
|
# def non_null_start_date(self):
|
|
# if self.start_date:
|
|
# return self.start_date
|
|
# else:
|
|
# return timezone.now() + timedelta(days=7)
|
|
|
|
# def sort_value(self):
|
|
# sort_score = 0
|
|
# if self.round.index:
|
|
# sort_score += 1 / (self.round.index + 1) * 1000 ** 2
|
|
# if self.group_stage.index:
|
|
# sort_score += 1 / (self.group_stage.index + 1) * 1000
|
|
# sort_score += self.index
|
|
# print(sort_score)
|
|
# return sort_score
|
|
|
|
class Team:
|
|
def __init__(self, image, names, scores, weight, is_winner, walk_out):
|
|
# print(f"image = {image}, names= {names}, scores ={scores}, weight={weight}, win={is_winner}")
|
|
self.image = image
|
|
self.names = names
|
|
self.scores = scores
|
|
self.weight = weight
|
|
self.is_winner = is_winner
|
|
self.walk_out = walk_out is not None
|
|
|
|
def to_dict(self):
|
|
return {
|
|
"image": self.image,
|
|
"names": self.names,
|
|
"scores": self.scores,
|
|
"weight": self.weight,
|
|
"is_winner": self.is_winner,
|
|
"walk_out": self.walk_out,
|
|
}
|
|
|
|
class LiveMatch:
|
|
def __init__(self, title, date, time_indication, court, started, ended, group_stage_name):
|
|
self.title = title
|
|
self.date = date
|
|
self.teams = []
|
|
self.time_indication = time_indication
|
|
self.court = court
|
|
self.started = started
|
|
self.ended = ended
|
|
self.has_walk_out = False
|
|
self.group_stage_name = group_stage_name
|
|
|
|
def add_team(self, team):
|
|
self.teams.append(team)
|
|
if team.walk_out is True:
|
|
self.has_walk_out = True
|
|
|
|
def to_dict(self):
|
|
return {
|
|
"title": self.title,
|
|
"date": self.date,
|
|
"teams": [team.to_dict() for team in self.teams],
|
|
"time_indication": self.time_indication,
|
|
"court": self.court,
|
|
"started": self.started,
|
|
"ended": self.ended,
|
|
"has_walk_out": self.has_walk_out,
|
|
"group_stage_name": self.group_stage_name,
|
|
}
|
|
|
|
def show_time_indication(self):
|
|
for team in self.teams:
|
|
if team.walk_out and len(team.scores) == 0:
|
|
return False
|
|
return True
|
|
|
|
def should_show_scores(self):
|
|
for team in self.teams:
|
|
if len(team.scores) > 0:
|
|
return True
|
|
return False
|
|
|