def players(self):
players = []
if self.status == 'Played':
tree = gsm.get_tree('en',
self.sport,
'get_matches',
type=self.tag,
id=self.gsm_id,
detailed=True,
retry=3)
for parent in ('lineups', 'lineups_bench'):
for parent_e in gsm.parse_element_for(tree.getroot(), parent):
for e in parent_e:
players.append({
'name': e.attrib['person'],
'gsm_id': e.attrib['person_id'],
})
if not players:
for team_id in [self.oponnent_A.gsm_id, self.oponnent_B.gsm_id]:
tree = gsm.get_tree('en',
self.sport,
'get_squads',
type='team',
id=team_id,
retry=3)
for e in gsm.parse_element_for(tree.getroot(), 'person'):
players.append({
'name': e.attrib['name'],
'gsm_id': e.attrib['person_id'],
})
return players
def person_detail_tab(request,
sport,
gsm_id,
tab,
tag='person',
update=False,
template_name='',
extra_context=None):
sport = get_sport_or_404(sport)
if sport.slug in ('hockey', 'basketball', 'americanfootball'):
return http.HttpResponseGone()
gsm_entity_class = model_class_for_tag(tag)
person, created = gsm_entity_class.objects.get_or_create(sport=sport,
tag=tag,
gsm_id=gsm_id)
context = {
'sport': sport,
'language': get_language_from_request(request),
'person': person,
'tab': tab,
}
if sport.slug in 'tennis':
t = gsm.get_tree(context['language'],
sport,
'get_players',
type='player',
id=person.gsm_id,
detailed='yes')
else:
t = gsm.get_tree(context['language'],
sport,
'get_career',
type='player',
id=person.gsm_id,
detailed='yes')
person.element = t.getroot().getchildren()[1]
if created:
person.name = unicode(person)
person.save()
if tab == 'picks':
context['bet_list_helper'] = BetListHelper(request,
exclude_columns=['support'],
**{tag: person})
template_name = [
'gsm/%s/%s/%s.html' % (sport.slug, 'person', tab),
'gsm/%s/%s.html' % ('person', tab),
]
context.update(extra_context or {})
return shortcuts.render_to_response(
template_name,
context,
context_instance=template.RequestContext(request))
def test(self, e):
try:
gsm.get_tree('en',
e.sport,
'get_%ss' % e.tag,
update=True,
retry=True,
type=e.tag,
id=e.gsm_id)
except gsm.HtmlInsteadOfXml:
logger.error('%s %s %s' % (e.sport, e.tag, e.gsm_id))
def entity_list(request,
sport,
tag,
update=False,
template_name='',
extra_context=None):
sport = get_sport_or_404(sport)
template_name = (
template_name,
'gsm/%s/%s_list.html' % (sport, tag),
'gsm/%s_list.html' % tag,
)
context = {
'sport': sport,
'language': get_language_from_request(request),
}
context['tree'] = gsm.get_tree(context['language'],
sport,
'get_%ss' % tag,
update=update)
context.update(extra_context or {})
return shortcuts.render_to_response(
template_name,
context,
context_instance=template.RequestContext(request))
def render(self, context):
if hasattr(self.method, 'resolve'):
method = self.method.resolve(context)
else:
method = self.method
for k, v in self.arguments.items():
if hasattr(v, 'resolve'):
self.arguments[k] = v.resolve(context)
tree = gsm.get_tree(
context['language'],
context['sport'],
method,
**self.arguments
)
if hasattr(self.key, 'resolve'):
key = self.key.resolve(context)
else:
key = self.key
context[key] = tree
return ''
def get_tree(self, *args, **kwargs):
kwargs['retry'] = 3000
kwargs['update'] = True
for k, v in kwargs.items():
if isinstance(v, datetime.datetime):
kwargs[k] = datetime_to_string(v.astimezone(london))
return gsm.get_tree(self.language, self.sport, *args,
**kwargs).getroot()
def has_squad(self):
if not hasattr(self, '_has_squad'):
tree = gsm.get_tree('en',
self.sport,
'get_squads',
type='team',
id=self.gsm_id,
detailed='yes',
statistics='yes')
self._has_squad = len(tree.findall('team')) > 0
return self._has_squad
def resync(self, element=None):
if not element:
detailed = self.sport.slug == 'tennis'
tree = gsm.get_tree('en',
self.sport,
'get_matches',
type='match',
id=self.gsm_id,
detailed=detailed,
update=True,
retry=True)
for e in gsm.parse_element_for(tree.getroot(), 'match'):
element = e
s = Sync(self.sport, False, False, False)
s.update(e)
def get_resultstable_for_season(season, team):
# get stats
tree = gsm.get_tree(context['language'],
sport,
'get_tables',
id=season.gsm_id,
type='season')
group_elements = tree.findall('competition/season/round/group')
resultstable_elements = tree.findall(
'competition/season/round/resultstable')
if group_elements and not resultstable_elements:
for group_element in group_elements:
for ranking_element in group_element.findall(
'resultstable/ranking'):
if ranking_element.attrib['team_id'] == str(team.gsm_id):
resultstable_elements = group_element
break
for resultstable in resultstable_elements:
if resultstable.attrib['type'] == 'total':
return resultstable
def team_detail_tab(request,
sport,
gsm_id,
tab,
tag='team',
update=False,
template_name='',
extra_context=None):
sport = get_sport_or_404(sport)
gsm_entity_class = model_class_for_tag(tag)
team = shortcuts.get_object_or_404(gsm_entity_class,
sport=sport,
tag=tag,
gsm_id=gsm_id)
context = {
'sport': sport,
'language': get_language_from_request(request),
'team': team,
'tab': tab,
}
tree = gsm.get_tree(context['language'],
sport,
'get_teams',
type='team',
id=team.gsm_id,
detailed='yes')
team.element = tree.getroot().findall('team')[0]
team.name = team.element.attrib['official_name']
template_name = [
'gsm/%s/%s/%s.html' % (sport.slug, tag, tab),
'gsm/%s/%s.html' % (tag, tab),
]
def get_reference_season(team):
# find reference seasons for stats
q = Season.objects.filter(sport=sport)
if 'type' in team.attrib.keys() and team.attrib['type']:
if team.attrib['type'] == 'club':
q = q.filter(competition__competition_type='club')
if q.filter(competition__competition_format=u'Domestic league'
).count():
q = q.filter(
competition__competition_format=u'Domestic league')
else:
q = q.filter(competition__important=True)
if team.attrib['type'] == 'national':
q = q.filter(competition__competition_type='international')
# exclude friendlies
q = q.exclude(competition__name_en='Friendlies')
# exclude seasons in which team is not participating
q = q.filter(
Q(session__oponnent_A=team)
| Q(session__oponnent_B=team)).distinct()
# any ongoing season ?
today = datetime.date.today()
ongoing = q.filter(end_date__gte=today, start_date__lte=today).count()
if ongoing == 1:
return q.get(end_date__gte=today, start_date__lte=today)
elif q.filter(end_date__lte=today).order_by('-end_date').count():
return q.filter(end_date__lte=today).order_by('-end_date')[0]
elif q.count():
return q.order_by('end_date')[0]
else:
return False
def get_resultstable_for_season(season, team):
# get stats
tree = gsm.get_tree(context['language'],
sport,
'get_tables',
id=season.gsm_id,
type='season')
group_elements = tree.findall('competition/season/round/group')
resultstable_elements = tree.findall(
'competition/season/round/resultstable')
if group_elements and not resultstable_elements:
for group_element in group_elements:
for ranking_element in group_element.findall(
'resultstable/ranking'):
if ranking_element.attrib['team_id'] == str(team.gsm_id):
resultstable_elements = group_element
break
for resultstable in resultstable_elements:
if resultstable.attrib['type'] == 'total':
return resultstable
if tab == 'home':
# find next sessions
q = Session.objects.filter(sport=sport)
q = q.filter(Q(oponnent_A=team) | Q(oponnent_B=team))
q_played = q.filter(
status='Played').order_by('-start_datetime').values_list(
'pk', flat=True).distinct()[:2]
q_next = q.filter(status__in=(
'Playing', 'Suspended', 'Fixture'
)).order_by('start_datetime').filter(
start_datetime__gte=datetime.date.today()).distinct().values_list(
'pk', flat=True)[:2]
context['next_sessions'] = Session.objects.filter(
pk__in=list(q_played) + list(q_next)).order_by('start_datetime')
reference_season = context['reference_season'] = get_reference_season(
team)
if reference_season:
context['resultstable'] = get_resultstable_for_season(
reference_season, team)
context['bet_list_helper'] = BetListHelper(
request,
exclude_columns=['support', 'sport'],
qs=Bet.objects.filter(Q(session__oponnent_A=team)
| Q(session__oponnent_B=team),
correction=0).order_by('?')[:3])
elif tab == 'squad':
if not team.has_squad():
return http.HttpResponseNotFound()
# squad finder
tree = gsm.get_tree(context['language'],
sport,
'get_squads',
type='team',
id=team.gsm_id,
detailed='yes',
statistics='yes')
for team_element in tree.findall('team'):
if str(team.gsm_id) == team_element.attrib['team_id']:
break
context['persons'] = []
# person orderer
positions = {}
for person_element in team_element.findall('person'):
if person_element.attrib['type'] in ('player', 'Joueur', 'Player'):
if 'position' not in person_element.attrib.keys():
position = _('player')
else:
position = person_element.attrib['position']
else:
continue # pass coach and crap
#position = person_element.attrib['type']
if position not in positions.keys():
positions[position] = []
person = GsmEntity(tag='person',
sport=sport,
gsm_id=person_element.attrib['person_id'],
name=person_element.attrib['name'])
person.element = person_element
positions[position].append(person)
context['persons'].append(person)
order = (
'Goalkeeper',
'Defender',
'Midfielder',
'Attacker',
)
ordered_positions = OrderedDict()
for key in order:
if key in positions.keys():
ordered_positions[key] = positions.pop(key)
for key, value in positions.items():
# copy what's left
ordered_positions[key] = value
context['positions'] = ordered_positions
elif tab == 'statistics':
reference_season = get_reference_season(team)
context['reference_season'] = reference_season
if reference_season:
context['resultstable'] = get_resultstable_for_season(
reference_season, team)
elif tab == 'picks':
context['bet_list_helper'] = x = BetListHelper(
request, team=team, exclude_columns=['support'])
elif tab == 'calendar':
context['next_page'] = context['previous_page'] = None
now = datetime.datetime.now()
past_sessions = team.get_sessions().filter(start_datetime__lte=now)
next_sessions = team.get_sessions().filter(start_datetime__gt=now)
page = int(request.GET.get('page', 0))
if page == 0:
context['sessions'] = [
s for s in reversed(
past_sessions.order_by('-start_datetime')[:5])
]
context['sessions'] += [
s for s in next_sessions.order_by('start_datetime')[:5]
]
elif page > 0:
minimum = 10 * page - 5
maximum = 10 * page + 5
context['sessions'] = next_sessions.order_by(
'start_datetime')[minimum:maximum]
elif page < 0:
minimum = 10 * page * -1 - 5
maximum = 10 * page * -1 + 5
context['sessions'] = [
s for s in reversed(
past_sessions.order_by('-start_datetime')[minimum:maximum])
]
if team.get_sessions().filter(start_datetime__lt=context['sessions']
[0].start_datetime).count():
context['previous_page'] = page - 1
if team.get_sessions().filter(start_datetime__gt=context['sessions'][
len(context['sessions']) - 1].start_datetime).count():
context['next_page'] = page + 1
context.update(extra_context or {})
return shortcuts.render_to_response(
template_name,
context,
context_instance=template.RequestContext(request))
def competition_detail_tab(request,
sport,
gsm_id,
tab,
tag='competition',
update=False,
template_name='',
extra_context=None):
sport = get_sport_or_404(sport)
gsm_entity_class = model_class_for_tag(tag)
competition = shortcuts.get_object_or_404(gsm_entity_class,
sport=sport,
tag=tag,
gsm_id=gsm_id)
context = {
'sport': sport,
'language': get_language_from_request(request),
'competition': competition,
'tab': tab,
}
template_name = [
'gsm/%s/%s/%s.html' % (sport.slug, tag, tab),
'gsm/%s/%s.html' % (tag, tab),
]
context['cup'] = cup = False
if competition.get_last_season().round_set.filter(
round_type='cup').count():
cup = context['cup'] = True
if tab == 'calendar':
page = int(request.GET.get('page', 0))
paginate_by = 15
center = 10
now = datetime.datetime.now()
sessions = Session.objects.filter(season__competition=competition)
next_sessions = sessions.filter(start_datetime__gt=now)
last_sessions = sessions.filter(
start_datetime__lte=now).order_by('-start_datetime')
if page == 0:
tmp = list(last_sessions[:paginate_by - center])
tmp.reverse()
context['sessions'] = tmp + list(next_sessions[:center])
try:
next_sessions[center]
context['next_page'] = page + 1
except IndexError:
pass
try:
last_sessions[paginate_by - center]
context['previous_page'] = page - 1
except IndexError:
pass
elif page > 0:
start = paginate_by * page
end = start + paginate_by
context['sessions'] = next_sessions[start:end]
context['previous_page'] = str(page - 1)
try:
next_sessions[end + 1]
context['next_page'] = page + 1
except IndexError:
pass
elif page < 0:
start = -paginate_by * page
end = start + paginate_by
context['sessions'] = reversed(last_sessions[start:end])
context['next_page'] = str(page + 1)
try:
last_sessions[end + 1]
context['previous_page'] = page - 1
except IndexError:
pass
if sport.slug == 'tennis':
season = competition.get_last_season()
seasons = competition.season_set.filter(end_date=season.end_date)
context['rankings_trees'] = trees = []
for season in seasons:
if season.season_type == 'double':
trees.append({
'tree':
gsm.get_tree(context['language'],
sport,
'get_rankings',
type=season.season_type,
tour_id=competition.championship.gsm_id),
'season':
season,
})
else:
trees.append({
'tree':
gsm.get_tree(context['language'],
sport,
'get_rankings',
type=season.season_type,
tour_id=competition.championship.gsm_id),
'season':
season,
})
if tab == 'picks':
context['bet_list_helper'] = BetListHelper(
request,
session__season__competition=competition,
exclude_columns=['support'])
elif tab == 'home':
context['bet_list_helper'] = BetListHelper(
request,
exclude_columns=['support', 'sport', 'competition'],
qs=Bet.objects.filter(
correction=0,
session__season__competition=competition).order_by('?')[:3])
season = competition.get_last_season()
if season.get_current_gameweek():
gameweek = context['gameweek'] = int(
request.GET.get('gameweek', season.get_current_gameweek()))
context['sessions'] = season.session_set.filter(gameweek=gameweek)
else:
context['sessions'] = season.session_set.filter(
start_datetime__gte=datetime.datetime.today())[:10]
context.update(extra_context or {})
return shortcuts.render_to_response(
template_name,
context,
context_instance=template.RequestContext(request))
def session_detail_tab(request,
sport,
gsm_id,
tab,
tag='match',
update=False,
template_name='',
extra_context=None):
sport = get_sport_or_404(sport)
gsm_entity_class = model_class_for_tag(tag)
session = shortcuts.get_object_or_404(Session, sport=sport, gsm_id=gsm_id)
context = {
'sport': sport,
'language': get_language_from_request(request),
'session': session,
'tab': tab,
}
t = gsm.get_tree(context['language'],
sport,
'get_matches',
type='match',
id=session.gsm_id,
detailed='yes')
c = t.getroot().getchildren()[1]
while c.tag != 'match':
c = c.getchildren()[0]
session.element = c
context['elements'] = {}
for child in c.getchildren():
context['elements'][child.tag] = child
try:
t = gsm.get_tree(context['language'],
sport,
'get_match_statistics',
id=session.gsm_id)
if t != False:
c = t.getroot().getchildren()[1]
while c.tag != 'match':
try:
c = c.getchildren()[0]
except IndexError:
break
context['statistics'] = statistics = c
except gsm.GsmException:
pass
now = datetime.datetime.now()
past_sessions_A = list(
session.oponnent_A.get_sessions().exclude(pk=session.pk).filter(
start_datetime__lte=now).order_by('-start_datetime')[:8])
next_sessions_A = list(session.oponnent_A.get_sessions().exclude(
pk=session.pk).filter(start_datetime__gt=now)[:2])
past_sessions_B = list(
session.oponnent_B.get_sessions().exclude(pk=session.pk).filter(
start_datetime__lte=now).order_by('-start_datetime')[:8])
next_sessions_B = list(session.oponnent_B.get_sessions().exclude(
pk=session.pk).filter(start_datetime__gt=now)[:2])
past_sessions_A.reverse()
past_sessions_B.reverse()
context['sessions_A'] = past_sessions_A + next_sessions_A
context['sessions_B'] = past_sessions_B + next_sessions_B
if tab == 'picks':
context['bet_list_helper'] = BetListHelper(request,
session=session,
exclude_columns=['support'])
template_name = [
'gsm/%s/%s/%s.html' % (sport.slug, 'session', tab),
'gsm/%s/%s.html' % ('session', tab),
]
context.update(extra_context or {})
return shortcuts.render_to_response(
template_name,
context,
context_instance=template.RequestContext(request))
def handle(self, *args, **options):
self.status_path = os.path.join(settings.VAR_ROOT, 'gsm_last_updated')
status = self.get_status()
now = local.localize(datetime.datetime.now())
last_updated = status['last_updated'] or now - datetime.timedelta(
hours=6)
if not last_updated.tzinfo:
last_updated = local.localize(last_updated)
minimal_date = now - datetime.timedelta(days=365 * 5)
if not minimal_date.tzinfo:
minimal_date = local.localize(minimal_date)
for sport in Sport.objects.all():
if args and sport.slug not in args:
continue
sync = Sync(sport,
last_updated,
minimal_date,
logger,
language='en')
if last_updated < now - datetime.timedelta(hours=23):
start_date = now - datetime.timedelta(hours=22)
else:
start_date = last_updated
root = sync.get_tree('get_deleted', start_date=start_date)
for child in root.getchildren():
if child.tag not in sync._tag_class_map:
continue
children = child.getchildren()
if children:
gsm_ids = [x.attrib['source_id'] for x in children]
sync._tag_class_map[child.tag].objects.filter(
tag=child.tag, gsm_id__in=gsm_ids,
sport=sport).delete()
if sport.slug == 'soccer':
root = sync.get_tree('get_matches_live',
update=True,
now_playing='yes')
for e in gsm.parse_element_for(root, 'match'):
sync.update(e)
for code, language in settings.LANGUAGES:
sync = Sync(sport,
last_updated,
minimal_date,
logger,
language=code,
names_only=code != 'en')
root = sync.get_tree('get_seasons',
update=True,
last_updated=last_updated)
if not root:
logger.error('Did not get tree for get_seasons')
return
for e in root.getchildren():
if e.tag == 'method' or sync.skip(e):
continue
if e.tag in sync._tag_class_map.keys():
sync.update(e)
delta = local.localize(
datetime.datetime.now()) + datetime.timedelta(minutes=7) - now
status['last_updated'] = now - delta
buggy_sessions = Session.objects.filter(
status='Fixture',
start_datetime__lte=datetime.datetime.now() -
datetime.timedelta(hours=2))
for session in buggy_sessions:
tree = gsm.get_tree('en',
session.sport,
'get_matches',
retry=30,
update=True,
type=session.tag,
id=session.gsm_id,
detailed=True)
for element in gsm.parse_element_for(tree.getroot(), 'match'):
break
d = datetime.datetime.now() - datetime.timedelta(days=6)
sync = Sync(session.sport, d, d, logger)
sync.update(element)
if not args:
self.store_status(status)
print "DONE UPDATING", status
def correct_for_session(session, element=None):
if element is None:
tree = gsm.get_tree('en',
session.sport,
'get_matches',
retry=30,
type=session.tag,
id=session.gsm_id,
detailed=True)
for element in gsm.parse_element_for(tree.getroot(), 'match'):
break
from bet.models import *
User = get_model('auth', 'user')
BetType = get_model('bookmaker', 'bettype')
if element.attrib['status'] in ('Fixture', 'Playing'):
return
if element.attrib['status'] == 'Cancelled':
Bet.objects.filter(session=session).update(
correction=BET_CORRECTION_CANCELED)
return
rewrite = (
'fs_A',
'fs_B',
'hts_A',
'hts_B',
'ets_A',
'ets_B',
'p1s_A',
'p1s_B',
'p2s_A',
'p2s_B',
'p3s_A',
'p3s_B',
'p4s_A',
'p4s_B',
'ps_A',
'ps_B',
'eps_A',
'eps_B',
)
attrib = {}
for k, v in element.attrib.items():
if v.isdigit():
attrib[k] = float(v)
else:
attrib[k] = v
to_update = User.objects.filter(ticket__bet__session=session).distinct()
to_correct = BetType.objects.filter(bet__session=session,
variable_type=None).distinct()
for t in to_correct:
if t.cancel_condition:
try:
condition = t.cancel_condition
if condition is None:
raise
for var in rewrite:
condition = condition.replace(var, 'attrib["%s"]' % var)
result = eval(condition)
if result:
Bet.objects.filter(
session=session,
bettype=t).update(correction=BET_CORRECTION_CANCELED)
continue
except:
pass
for c in t.betchoice_set.all():
bets = Bet.objects.filter(session=session, bettype=t, choice=c)
try:
condition = c.condition
if condition is None:
raise
for var in rewrite:
condition = condition.replace(var, 'attrib["%s"]' % var)
set = []
for child in element.getchildren():
if child.tag == 'set':
set.append(element.attrib)
result = eval(condition)
if result:
correction = BET_CORRECTION_WON
else:
correction = BET_CORRECTION_LOST
bets.update(correction=correction)
except:
bets.update(flagged=True)
for u in to_update.values_list('pk', flat=True):
refresh_betprofile_for_user_nospool({'userpk': u})
# the next part uses bet.save() which should trigger profile refresh
to_correct = Bet.objects.filter(session=session).exclude(
bettype__variable_type=None).distinct()
goalers = []
goalers_with_extra = []
goal_elements = element.findall('goals/goal/event') or []
for e in goal_elements:
if e.attrib['code'] != 'G':
pass
if not e.attrib.get('minute_extra', None):
goalers.append(float(e.attrib['person_id']))
goalers_with_extra.append(float(e.attrib['person_id']))
for bet in to_correct:
try:
condition = bet.choice.condition
if condition is None:
raise
for var in rewrite:
condition = condition.replace(var, 'attrib["%s"]' % var)
set = []
for child in element.getchildren():
if child.tag == 'set':
set.append(element.attrib)
result = eval(condition)
if result:
correction = BET_CORRECTION_WON
else:
correction = BET_CORRECTION_LOST
bet.correction = correction
except:
bet.flagged = True
bet.save()
