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