def get_context_data(self, **kwargs):
context = \
super(PeopleRecordingStatsView, self).get_context_data(**kwargs)
language = get_current_language(self.request)
people = context['people']
people = people.annotate(num_recordings=models.Count('recording'))
for person in context['people']:
# recordings = Recording.objects\
# .filter(person=person, sentence__language=language)
# score = 0
# for recording in recordings:
# score = score + recording.calculate_score()
# person.score = int(score)
person.num_recordings = person.recording_set.count()
if person.user is None:
person.name = 'Anonymous Kumara'
elif person.user.username == '':
person.name = 'Anonymous Kumara'
else:
person.name = person.user.username
return context
def get_context_data(self, **kwargs):
context = \
super(PersonQCStatsView, self).get_context_data(**kwargs)
person = get_person(self.request)
language = get_current_language(self.request)
qcs = QualityControl.objects.filter(person=person)
pks = []
for qc in qcs:
if qc.content_type.name.lower() in 'recording' \
and qc.content_object.sentence.language == language:
pks.append(qc.pk)
qcs = qcs.filter(pk__in=pks)
now = timezone.now()
today_begining = \
datetime.datetime.combine(now, datetime.time())
todays_qcs = qcs\
.filter(updated__gte=today_begining).order_by('updated')
stats = {
'qcs': build_qualitycontrol_stat_dict(qcs),
'qcs_today': build_qualitycontrol_stat_dict(todays_qcs)
}
context['person'] = person
context['stats'] = stats
return context
def get_queryset(self):
language = get_current_language(self.request)
return Person.objects\
.filter(recording__sentence__language=language)\
.exclude(leaderboard=False)\
.annotate(num_recordings=models.Count('recording'))\
.order_by('-num_recordings')
def get_sentences(request,
recordings=None,
person=None,
current_language=None):
''' Returns sentences without recordings '''
if person is None:
person = get_or_create_person(request)
if current_language is None:
current_language = get_current_language(request)
sentences = Sentence.objects\
.filter(language=current_language)\
.filter(quality_control__approved=True)
query = sentences.filter(recording__isnull=True)
# This creates a bad loop if only one sentence without a recording
# only that sentence is served. Perhpas we should order by num recordings
if query.count() > 100:
sentences = query
else:
sentences = sentences\
.exclude(recording__person=person)
return sentences
def __call__(self, request):
# Code to be executed for each request before
# the view (and later middleware) are called.
set_cookie = False
if request.COOKIES.has_key(settings.LANGUAGE_COOKIE_NAME):
language = request.COOKIES.get(settings.LANGUAGE_COOKIE_NAME)
elif hasattr(request, 'user'):
if request.user.is_authenticated():
current_language = get_current_language(request)
if current_language:
set_cookie = True
else:
language = translation.get_language()
# set_cookie = True
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
response = self.get_response(request)
if set_cookie:
response.set_cookie(settings.LANGUAGE_COOKIE_NAME,
language,
max_age=2 * 365 * 24 * 60 * 60,
domain=settings.SESSION_COOKIE_DOMAIN,
secure=settings.SESSION_COOKIE_SECURE or None)
# Code to be executed for each request/response after
# the view is called.
translation.deactivate(
) # Deactivates our langauge after we've processed the request.
return response
def get_context_data(self, **kwargs):
context = \
super(PersonQCStatsView, self).get_context_data(**kwargs)
person = get_person(self.request)
language = get_current_language(self.request)
qcs = RecordingQualityControl.objects\
.filter(person=person)\
.filter(recording__language=language)
now = timezone.now()
today_begining = \
datetime.datetime.combine(now, datetime.time())
todays_qcs = qcs\
.filter(updated__gte=today_begining).order_by('updated')
stats = {
'qcs': build_qualitycontrol_stat_dict(qcs),
'qcs_today': build_qualitycontrol_stat_dict(todays_qcs)
}
context['person'] = person
context['stats'] = stats
return context
def get_context_data(self, **kwargs):
context = \
super(GroupStatsView, self).get_context_data(**kwargs)
group = context['group']
context['x_title'] = _('Group Leaderboard: {0}').format(group)
context['x_description'] = _("Leaderboard for members of {0}.").format(
group)
language = get_current_language(self.request)
people = Person.objects.all()
valid_members = people
valid_members = get_valid_group_members(group, valid_members)
invalid_members = people
invalid_members = get_invalid_group_members(group, invalid_members)
# people = people\
# .filter(recording__sentence__language=language)
# score, count = get_competition_group_score(group)
num_recordings = 0
if valid_members:
for member in valid_members:
recordings = filter_qs_for_competition(
Recording.objects.filter(person=member))
member.num_recordings = recordings.count()
if invalid_members:
invalid_members = invalid_members\
.annotate(num_groups=Count('groups', distinct=True))
for member in invalid_members:
recordings = filter_qs_for_competition(
Recording.objects.filter(person=member))
member.num_recordings = recordings.count()
member.verified = email_verified(member)
form = ResendEmailVerificationForm()
group.duration_hours = group.duration / 60 / 60
context['group'] = group
context['score'] = group.score
context['form'] = form
context['people'] = people.filter(groups=group)
context['valid_members'] = valid_members
context['invalid_members'] = invalid_members
return context
def get_sentences(request, recordings=None):
''' Returns sentences without recordings '''
current_language = get_current_language(request)
if request.user.is_authenticated():
if not recordings:
recordings = Recording.objects.filter(
person__user=request.user, sentence__language=current_language)
sentences = Sentence.objects.filter(language=current_language).exclude(
pk__in=[i.sentence.pk for i in recordings])
return sentences
else:
return get_sentences_annonymous(request)
def get_context_data(self, **kwargs):
context = \
super(MahiTahi, self).get_context_data(**kwargs)
language = get_current_language(self.request)
groups = context['groups']
for group in groups:
group.growth_rate = mahi_tahi(group)
context['groups'] = groups
return context
def get_sentences(request,
recordings=None,
person=None,
current_language=None):
''' Returns sentences without recordings '''
if person is None:
person = get_or_create_person(request)
if current_language is None:
current_language = get_current_language(request)
# Only get approved sentences
# sentences = Sentence.objects.filter(language=current_language)\
# .annotate(sum_approved=Sum(
# Case(
# When(
# quality_control__approved=True,
# then=Value(1)),
# When(
# quality_control__approved=False,
# then=Value(0)),
# default=Value(0),
# output_field=IntegerField())))\
# .filter(sum_approved__gte=1)
# This appears to fail.
# Only return sentences which the person hasn't recorded
# sentences = sentences\
# .annotate(person_no_more_recording=Sum(
# Case(
# When(
# recording__isnull=True,
# then=Value(0)),
# When(
# recording__person=person,
# then=Value(-1)),
# default=Value(0),
# output_field=IntegerField())))\
# .filter(person_no_more_recording=0)
# sentences = sentences\
# .exclude(recording__person=person)
# # .exclude(~Q(recordings=None))
sentences = Sentence.objects.filter(language=current_language)\
.exclude(quality_control=None)\
.filter(quality_control__approved=True)\
.exclude(recording__person=person)
return sentences
def person(request, uuid):
# # from django.utils.translation import activate
# # activate('mi')
lang = get_current_language(request)
sentence = get_next_sentence(request)
logger.debug('Language Cookie Is: {0}'.format(lang))
output = _('Today is %(month)s %(day)s.') % {'month': 10, 'day': 10}
return render(request, 'people/person.html', {
'language': lang,
'output': output,
'sentence': sentence
})
return render(request, 'people/person.html')
def get_queryset(self):
person = get_person(self.request)
language = get_current_language(self.request)
people = Person.objects.filter(user__is_staff=True)
people = people\
.annotate(
num_approved=models.Sum(
Case(
When(
recordingqualitycontrol__isnull=True,
then=Value(0)),
When(
recordingqualitycontrol__approved=True,
then=Value(1)),
When(
recordingqualitycontrol__approved=False,
then=Value(0)),
default=Value(0),
output_field=IntegerField())))\
.annotate(
num_good=models.Sum(
Case(
When(
recordingqualitycontrol__isnull=True,
then=Value(0)),
When(
recordingqualitycontrol__good__gte=1,
then=Value(1)),
default=Value(0),
output_field=IntegerField())))\
.annotate(
num_bad=models.Sum(
Case(
When(
recordingqualitycontrol__isnull=True,
then=Value(0)),
When(
recordingqualitycontrol__bad__gte=1,
then=Value(1)),
default=Value(0),
output_field=IntegerField())))\
.order_by('-num_reviews')
return people
def get_context_data(self, **kwargs):
context = \
super(GroupsStatsView, self).get_context_data(**kwargs)
language = get_current_language(self.request)
groups = context['groups']
# Tryin to do sort stuff :/
path = self.request.get_full_path()
if '?' not in path:
path = path + '?sort_by=-score&page=1'
context['path'] = path
# context['groups'] = groups
return context
def get_context_data(self, **kwargs):
context = \
super(PersonRecordingStatsView, self).get_context_data(**kwargs)
person = get_person(self.request)
language = get_current_language(self.request)
recordings = Recording.objects.filter(sentence__language=language,
person=person)
# Assume for now user is in NZ timezone = UTC + 12 hours
time_offset = 0
now = timezone.now() + datetime.timedelta(hours=time_offset)
# Find the day for NZ, then take us back to utc time.
today_begining = \
datetime.datetime.combine(now, datetime.time()) - \
datetime.timedelta(hours=time_offset)
# This logical is compared against utc time - the default timezone for our data
# I presume django deals with this timezoen stuff anyway?
todays_recordings = recordings.filter(
created__gte=today_begining).order_by('created')
stats = {
'recordings': build_recordings_stat_dict(recordings),
'recordings_today': build_recordings_stat_dict(todays_recordings)
}
stats['recordings_today']['start_time'] = today_begining
stats['recordings_today']['end_time'] = timezone.now()
if todays_recordings:
stats['recordings_today']['earliest_time'] = todays_recordings[
0].created
stats['recordings_today']['latest_time'] = todays_recordings[
todays_recordings.count() - 1].created
context['person'] = person
context['stats'] = stats
return context
def get_context_data(self, **kwargs):
context = \
super(GroupsStatsView, self).get_context_data(**kwargs)
language = get_current_language(self.request)
groups = context['groups']
# for group in groups:
# # members = get_valid_group_members(group)
# # recordings = filter_qs_for_competition(
# # Recording.objects.filter(person__in=members))
# group.duration_hours = group.duration/60/60
# Tryin to do sort stuff :/
path = self.request.get_full_path()
if '?' not in path:
path = path + '?sort_by=-score&page=1'
context['path'] = path
# context['groups'] = groups
return context
def get_context_data(self, **kwargs):
context = super(StatsView, self).get_context_data(**kwargs)
user = self.request.user
language = get_current_language(self.request)
# qc = self.get_queryset()
# qc_s = qc.filter(content_type='sentence')
# qc_r = qc.filter(content_type='recording')
sentences = Sentence.objects.filter(language=language)
recordings = Recording.objects.filter(sentence__language=language)
people = Person.objects.all()
length = Recording.objects.aggregate(Sum('duration'))
approved_sentences = sentences.filter(quality_control__approved=True)
approved_recordings = recordings.filter(quality_control__approved=True)
seconds = float(length['duration__sum'])
hours = int(seconds / (60.0 * 60))
minutes = int((seconds - (60 * 60.0) * hours) / 60.0)
seconds = int(seconds - (60 * 60.0) * hours - 60.0 * minutes)
recording_votes = get_net_votes(recordings)
sentence_votes = get_net_votes(sentences)
stats = {
'recordings': {
'total':
recordings.count(),
'num_approved':
get_num_approved(recordings),
'up_votes':
recording_votes[0],
'down_votes':
recording_votes[1],
'duration':
"{:02d}:{:02d}:{:02d} ".format(hours, minutes, seconds),
},
'sentences': {
'total': sentences.count(),
'num_approved': get_num_approved(sentences),
'up_votes': sentence_votes[0],
'down_votes': sentence_votes[1],
},
}
stats_by_proficiency = {}
for level in KnownLanguage.PROFICIENCIES:
query = recordings\
.filter(person__known_languages__language=language)\
.filter(person__known_languages__level_of_proficiency=level[0])
recording_votes = get_net_votes(query)
length = query.aggregate(Sum('duration'))
if length['duration__sum'] is None:
seconds = 0
else:
seconds = float(length['duration__sum'])
hours = int(seconds / (60.0 * 60))
minutes = int((seconds - (60 * 60.0) * hours) / 60.0)
seconds = int(seconds - (60 * 60.0) * hours - 60.0 * minutes)
stats_by_proficiency[level[0]] = {
'language_level': str(level[1]),
'total': query.count(),
'num_approved': get_num_approved(query),
'up_votes': recording_votes[0],
'down_votes': recording_votes[1],
'duration':
"{:02d}:{:02d}:{:02d} ".format(hours, minutes, seconds)
}
context['user'] = user
context['num_recordings'] = recordings.count()
context['stats'] = stats
context['num_sentences'] = sentences.count()
context['approved_sentences'] = approved_sentences.count()
context['total_duration'] = "{:02d}:{:02d}:{:02d} ".format(
hours, minutes, seconds)
context['recordings_by_proficiency'] = stats_by_proficiency
return context
def choose_language(request):
person = get_or_create_person(request)
if not person:
return redirect(reverse('account_login'))
current_language = get_current_language(request)
if current_language:
set_current_language_for_person(person, current_language)
next_page = request.GET.get('next', None)
known_languages = KnownLanguage.objects.filter(person=person).count()
if known_languages > 0:
extra = known_languages
else:
extra = 1
unknown = get_unknown_languages(person)
KnownLanguageFormset = inlineformset_factory(
Person,
KnownLanguage,
form=KnownLanguageFormWithPerson,
fields=('language', 'level_of_proficiency', 'person', 'accent',
'dialect'),
max_num=get_num_supported_languages(),
extra=extra,
)
# formset = KnownLanguageFormset(form_kwargs={'person':person})
# KnownLanguageFormsetWithPerson = inlineformset_factory(Person, KnownLanguage, form=form, fields=('language','level_of_proficiency','person'), max_num=get_num_supported_languages(), extra=known_languages+1)
formset = KnownLanguageFormset(instance=person,
form_kwargs={
'person': person,
'require_proficiency': True
})
if request.method == 'POST':
# Upon first post to the person choosing their language
# We can ensure that the user just signed up
person.just_signed_up = False
person.save()
formset = KnownLanguageFormset(request.POST,
request.FILES,
instance=person,
form_kwargs={
'person': person,
'require_proficiency': True
})
if formset.has_changed():
if formset.is_valid():
instances = formset.save()
current_language = get_current_language(request)
if not current_language:
for instance in instances:
if instance.active:
current_language = obj.language
if not current_language:
current_language = translation.get_language()
try:
set_current_language_for_person(person, current_language)
except:
logger.debug(
"We may be trying to set a language when knownlanguage doens't exist"
)
if next_page:
response = redirect(reverse(next_page))
else:
response = redirect(reverse('people:choose_language'))
response = set_language_cookie(response, current_language)
return response
else:
if formset.is_valid():
if next_page:
return redirect(reverse(next_page))
# else:
# return redirect(reverse('people:choose_language'))
# formset = KnownLanguageFormsetWithPerson(instance=person)
response = render(
request, 'people/choose_language.html', {
'known_language_form': formset,
'known_languages': known_languages,
'unknown_languages': unknown,
'just_signup_track': person.just_signed_up,
})
current_language = get_current_language(request)
if current_language:
set_current_language_for_person(person, current_language)
response = set_language_cookie(response, current_language)
else:
logger.debug('no current language')
return response
def get_sentences_annonymous(request):
current_language = get_current_language(request)
sentences_without_recordings = Sentence.objects.filter(
language=current_language, recording__is_null=True)
return sentences_without_recordings
def get_context_data(self, **kwargs):
context = super(RecordingStatsView, self).get_context_data(**kwargs)
user = self.request.user
language = get_current_language(self.request)
recordings = Recording.objects.all().order_by('-created')
start_date = recordings.last().created
end_date = recordings.first().created
start_day = \
timezone.make_aware(
datetime.datetime.combine(start_date, datetime.time()),
timezone.get_default_timezone())
end_day = \
timezone.make_aware(
datetime.datetime.combine(end_date, datetime.time()),
timezone.get_default_timezone())
day_counter = 1
timezone_shift = datetime.timedelta(hours=0)
day_offset = datetime.timedelta(days=day_counter)
next_day = start_day - day_offset
data = {'recordings': {}, 'growth_rate': {}}
data = {
'recordings': {
'labels': [],
'values': [],
},
'growth_rate': {
'labels': [],
'values': [],
},
}
total_recordings = 0
counter = 0
tomorrow = next_day + day_offset
# next_day = next_day
while next_day < timezone.now() - timezone_shift:
if counter == 0:
start_30days_back = timezone.now() - datetime.timedelta(
days=30)
# if start_30days_back > next_day:
tomorrow = timezone.make_aware(
datetime.datetime.combine(start_30days_back,
datetime.time()),
timezone.get_default_timezone())
r = recordings.filter(
created__gte=next_day+timezone_shift,
created__lt=tomorrow+timezone_shift)\
.aggregate(Sum('duration'))
if r['duration__sum'] is None:
r['duration__sum'] = 0
total_recordings = (r['duration__sum'] / 60) + total_recordings
data['recordings']['labels'].append(
(next_day).strftime('%d-%m-%y'))
data['recordings']['values'].append(total_recordings)
try:
data['growth_rate']['labels'].append(
(next_day).strftime('%d-%m-%y'))
data['growth_rate']['values'].append(
total_recordings -
data['recordings']['values'][counter - 1])
except IndexError:
data['growth_rate']['values'].append(total_recordings)
# try:
# next_day = timezone.make_aware(
# tomorrow,
# timezone.get_default_timezone())
# except:
next_day = tomorrow
tomorrow = tomorrow + day_offset
counter = counter + 1
# context['labels'] = [key for key in data['recordings']]
# context['values'] = [
# "{0:0.2d}".format(data['recordings'][i]) for i in data['recordings']]
context['data'] = data
context['start_day'] = start_day
context['end_day'] = end_day
context['start_date'] = start_date
context['end_date'] = end_date
return context
