def auto_publish_reports(*args, **kwargs):
'''
Publish all reports for this week
'''
from datetime import date, timedelta
from sport.models import SportWeek
from django.db.models import Count
from helpers import date_to_week
today = date.today() - timedelta(
days=1) # just to be sure we don't send the next week !
week, year = date_to_week(today)
reports = SportWeek.objects.filter(
year=year, week=week, published=False).order_by('user__username')
reports = reports.filter(
user__auto_send=True) # Auto send must be enabled per user
for r in reports:
# Skip empty report
agg = r.days.aggregate(nb=Count('sessions'))
if not agg['nb']:
print 'No active sessions for report %s' % r
continue
# Publish
for m in r.user.memberships.all():
r.publish(m, 'https://runreport.fr') # TODO : use a config
print 'Published %s' % r
def auto_publish_reports(*args, **kwargs):
"""
Publish all reports for this week
"""
from datetime import date, timedelta
from sport.models import SportWeek
from django.db.models import Count
from helpers import date_to_week
today = date.today() - timedelta(days=1) # just to be sure we don't send the next week !
week, year = date_to_week(today)
reports = SportWeek.objects.filter(year=year, week=week, published=False).order_by("user__username")
reports = reports.filter(user__auto_send=True) # Auto send must be enabled per user
for r in reports:
# Skip empty report
agg = r.days.aggregate(nb=Count("sessions"))
if not agg["nb"]:
print "No active sessions for report %s" % r
continue
# Publish
for m in r.user.memberships.all():
r.publish(m, "https://runreport.fr") # TODO : use a config
print "Published %s" % r
def attach_session(self, user, identity):
# Chekc field
fields = ('name', 'date', 'distance', 'sport', 'time')
for f in fields:
if f not in identity:
raise Exception("Missing identity field : %s" % f)
# Attach Activity to valid session
week, year = date_to_week(identity['date'])
sport_week,_ = SportWeek.objects.get_or_create(user=user, year=year, week=week)
day,_ = SportDay.objects.get_or_create(date=identity['date'], week=sport_week)
# Search an existing session
sessions = day.sessions.filter(sport=identity['sport'].get_parent(), track__isnull=True)
min_ratio = None
if sessions.count():
# Sort by closest distance & time
# using a rationalised diff for distance & time
for s in sessions:
ratio_time, ratio_distance = None, None
if s.time and identity['time']:
t = identity['time'].total_seconds()
ratio_time = abs(s.time.total_seconds() - t) / t
if s.distance and identity['distance']:
ratio_distance = abs(s.distance - identity['distance']) / identity['distance']
# Sum ratios with compensation for empty values
ratio = (ratio_time or 0) + (ratio_distance or 0)
if ratio_time is None or ratio_distance is None:
ratio *= 2
# Compare ratio to find best session
if min_ratio is None or ratio < min_ratio:
min_ratio = ratio
self.session = s
# Update performances & name
keys = ('name', 'time', 'distance', 'elevation_gain', 'elevation_loss')
for key in keys:
identity_value = identity.get(key)
if identity_value and not getattr(self.session, key):
setattr(self.session, key, identity_value)
self.session.save()
else:
# Create new session
data = {
'sport' : identity['sport'].get_parent(),
'day' : day,
'time' : identity['time'],
'distance' : identity['distance'],
'name' : identity['name'],
'elevation_gain' : identity['elevation_gain'],
'elevation_loss' : identity['elevation_loss'],
}
self.session = SportSession.objects.create(**data)
def get_object(self):
# Load day, report and eventual session
self.day = date(int(self.get_year()), int(self.get_month()), int(self.get_day()))
week, year = date_to_week(self.day)
self.week, created = SportWeek.objects.get_or_create(user=self.get_user(), year=year, week=week)
try:
self.object = SportDay.objects.get(week=self.week, date=self.day)
except:
self.object = SportDay(week=self.week, date=self.day)
return self.object
def build_day(self, user, day):
# Build new week/day chain
w,y = date_to_week(day)
published = day < (self.today - timedelta(days=6)).date()
week,_ = SportWeek.objects.get_or_create(user=user, week=w, year=y, defaults={'published':published,})
d,_ = SportDay.objects.get_or_create(week=week, date=day)
# Build random number of session
# with a higher chance to get 1 session per day
for i in range(0, random.choice([1,1,1,1,1,1,1,2,2,3])):
self.build_session(d)
def attach_session(self, user, identity):
# Chekc field
fields = ('name', 'date', 'distance', 'sport', 'time')
for f in fields:
if f not in identity:
raise Exception("Missing identity field : %s" % f)
# Attach Activity to valid session
week, year = date_to_week(identity['date'])
sport_week, _ = SportWeek.objects.get_or_create(user=user,
year=year,
week=week)
day, _ = SportDay.objects.get_or_create(date=identity['date'],
week=sport_week)
# Search an existing session
sessions = day.sessions.filter(sport=identity['sport'].get_parent(),
track__isnull=True)
min_ratio = None
if sessions.count():
# Sort by closest distance & time
# using a rationalised diff for distance & time
for s in sessions:
ratio_time, ratio_distance = None, None
if s.time and identity['time']:
t = identity['time'].total_seconds()
ratio_time = abs(s.time.total_seconds() - t) / t
if s.distance and identity['distance']:
ratio_distance = abs(s.distance - identity['distance']
) / identity['distance']
# Sum ratios with compensation for empty values
ratio = (ratio_time or 0) + (ratio_distance or 0)
if ratio_time is None or ratio_distance is None:
ratio *= 2
# Compare ratio to find best session
if min_ratio is None or ratio < min_ratio:
min_ratio = ratio
self.session = s
# Update title
if identity['name'] and not self.session.name:
self.session.name = identity['name']
self.session.save()
else:
# Create new session
self.session = SportSession.objects.create(
sport=identity['sport'].get_parent(),
day=day,
time=identity['time'],
distance=identity['distance'],
name=identity['name'])
def _build_day(self, user, date):
# Internal used to create week & day hierarchy
# Used on PSA move too (so date need to be specified)
# Load week
w, year = date_to_week(date)
week,_ = SportWeek.objects.get_or_create(year=year, week=w, user=user)
# Load day
day,_ = SportDay.objects.get_or_create(week=week, date=date)
return day
def _build_day(self, user, date):
# Internal used to create week & day hierarchy
# Used on PSA move too (so date need to be specified)
# Load week
w, year = date_to_week(date)
week, _ = SportWeek.objects.get_or_create(year=year, week=w, user=user)
# Load day
day, _ = SportDay.objects.get_or_create(week=week, date=date)
return day
def apply(self, application):
'''
Apply this plan session to a user
'''
if not self.date:
raise Exception('No date to apply this session')
# Load week
w, year = date_to_week(self.date)
week, _ = SportWeek.objects.get_or_create(year=year,
week=w,
user=application.user)
# Load day
day, _ = SportDay.objects.get_or_create(week=week, date=self.date)
# Check a session does not already have this plan session
try:
psa = PlanSessionApplied.objects.get(plan_session=self,
sport_session__day=day)
except PlanSessionApplied.DoesNotExist:
psa = None
if psa:
# retrieve sport session
session = psa.sport_session
else:
# Load session
defaults = {
'name': self.name,
'distance': self.distance,
'time': self.time,
}
session, _ = SportSession.objects.get_or_create(sport=self.sport,
day=day,
type=self.type,
defaults=defaults)
# Apply plan session
PlanSessionApplied.objects.create(plan_session=self,
sport_session=session,
application=application)
# Copy all comments
if self.comments:
# Build conversation if needed
if not session.comments_private:
session.build_conversation('private')
for c in self.comments.messages.all():
c.copy(session.comments_private)
def get_object(self):
# Load day, report and eventual session
self.day = date(int(self.get_year()), int(self.get_month()),
int(self.get_day()))
week, year = date_to_week(self.day)
self.week, created = SportWeek.objects.get_or_create(
user=self.get_user(), year=year, week=week)
try:
self.object = SportDay.objects.get(week=self.week, date=self.day)
except:
self.object = SportDay(week=self.week, date=self.day)
return self.object
def build_day(self, user, day):
# Build new week/day chain
w, y = date_to_week(day)
published = day < (self.today - timedelta(days=6)).date()
week, _ = SportWeek.objects.get_or_create(user=user,
week=w,
year=y,
defaults={
'published': published,
})
d, _ = SportDay.objects.get_or_create(week=week, date=day)
# Build random number of session
# with a higher chance to get 1 session per day
for i in range(0, random.choice([1, 1, 1, 1, 1, 1, 1, 2, 2, 3])):
self.build_session(d)
def get_context_data(self, *args, **kwargs):
context = super(RunCalendarDay, self).get_context_data(*args, **kwargs)
context['now'] = datetime.now()
context['forms'] = self.get_sessions_forms(self.day, self.object)
# Previous week sunday
week = self.object.week
diff = timedelta(days=1)
context['previous_day'] = week.get_date_start() - diff
# Next week monday
context['next_day'] = week.get_date_end() + diff
# Add previous week, not published
if self.request.user.is_authenticated():
try:
w, y = date_to_week(date.today() - timedelta(days=7))
context['previous_week'] = SportWeek.objects.get(
user=self.request.user, year=y, week=w, published=False)
except SportWeek.DoesNotExist:
context['previous_week'] = None
# Add friends with activities on the same day
friends = []
user = self.get_user()
if user == self.request.user:
friends = SportSession.objects.filter(
day__date=self.day, day__week__user__in=user.friends.all())
friends = friends.prefetch_related('day', 'day__week', 'sport',
'day__week__user', 'track')
friends = friends.order_by('day__week__user__first_name')
context['friends_sessions'] = friends
# Friends short list
if friends:
friend_ids = set(
friends.values_list('day__week__user',
flat=True).order_by('-updated'))
context['friends_shortlist'] = Athlete.objects.filter(
pk__in=friend_ids)
# Check task on week
check_task(week)
return context
def apply(self, application):
'''
Apply this plan session to a user
'''
if not self.date:
raise Exception('No date to apply this session')
# Load week
w, year = date_to_week(self.date)
week,_ = SportWeek.objects.get_or_create(year=year, week=w, user=application.user)
# Load day
day,_ = SportDay.objects.get_or_create(week=week, date=self.date)
# Check a session does not already have this plan session
try:
psa = PlanSessionApplied.objects.get(plan_session=self, sport_session__day=day)
except PlanSessionApplied.DoesNotExist:
psa = None
if psa:
# retrieve sport session
session = psa.sport_session
else:
# Load session
defaults = {
'name' : self.name,
'distance' : self.distance,
'time' : self.time,
}
session,_ = SportSession.objects.get_or_create(sport=self.sport, day=day, type=self.type, defaults=defaults)
# Apply plan session
PlanSessionApplied.objects.create(plan_session=self, sport_session=session, application=application)
# Copy all comments
if self.comments:
# Build conversation if needed
if not session.comments_private:
session.build_conversation('private')
for c in self.comments.messages.all():
c.copy(session.comments_private)
def get_context_data(self, *args, **kwargs):
context = super(RunCalendarDay, self).get_context_data(*args, **kwargs)
context['now'] = datetime.now()
context['forms'] = self.get_sessions_forms(self.day, self.object)
# Previous week sunday
week = self.object.week
diff = timedelta(days=1)
context['previous_day'] = week.get_date_start() - diff
# Next week monday
context['next_day'] = week.get_date_end() + diff
# Add previous week, not published
if self.request.user.is_authenticated():
try:
w, y = date_to_week(date.today() - timedelta(days=7))
context['previous_week'] = SportWeek.objects.get(user=self.request.user, year=y, week=w, published=False)
except SportWeek.DoesNotExist:
context['previous_week'] = None
# Add friends with activities on the same day
friends = []
user = self.get_user()
if user == self.request.user:
friends = SportSession.objects.filter(day__date=self.day, day__week__user__in=user.friends.all())
friends = friends.prefetch_related('day', 'day__week', 'sport', 'day__week__user', 'track')
friends = friends.order_by('day__week__user__first_name')
context['friends_sessions'] = friends
# Friends short list
if friends:
friend_ids = set(friends.values_list('day__week__user', flat=True).order_by('-updated'))
context['friends_shortlist'] = Athlete.objects.filter(pk__in=friend_ids)
# Check task on week
check_task(week)
return context
def __init__(self):
self._today = date.today()
self._week, self._year = date_to_week(date.today())
