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 create(self, validated_data): request = self.context['request'] validated_data['uploaded_by'] = get_person(request) method = request.GET.get('method', '') if 'stream' in method: logger.debug(type(validated_data['audio_file'])) result = transcribe_audio_quick(validated_data['audio_file']) text = result['transcription'].strip() validated_data['transcription'] = text # For streaming, let's not create an AFT # Instead we should just have a log of a transcription # I meand we could keep the audio as well... aft = AudioFileTranscription() for key in validated_data.keys(): setattr(aft, key, validated_data[key]) try: aft.metadata = result['metadata'] except KeyError: pass return aft if 'name' not in validated_data.keys(): fname = validated_data['audio_file'].name validated_data['name'] = ''.join(fname.split('.')[:-1]) return super(AudioFileTranscriptionSerializer, self).create(validated_data)
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): person = get_person(self.request) queryset = TranscriptionSegment.objects\ .filter(parent__uploaded_by=person)\ .order_by('start')\ .order_by('-parent__created') return queryset
def get_queryset(self): person = get_person(self.request) qs = AudioFileTranscription.objects\ .filter(uploaded_by=person)\ .annotate(num_segments=Count('transcriptionsegment'))\ .filter(num_segments__gte=1)\ .order_by('-updated') return qs
def has_object_permission(self, request, view, obj): person = get_person(request) if person == obj.person: # Only a person can view/edit his/her own data return True else: self.message = _("You're not allowed to view this information.") return False
def to_representation(self, value): serializer = QualityControlSerializer(value, context=self.parent.context) person = get_person(self.parent.context['request']) data = serializer.data return data if person is data['person']: return serializer.data else: return None
def has_object_permission(self, request, view, obj): if request.method in permissions.SAFE_METHODS: self.message = _("Only staff can read recordings.") if request.user.is_staff: person = get_person(request) cache.set('{0}:{0}:listen'.format(person.uuid, obj.id), True, 15) return True else: if request.method in ['PUT']: if request.user.is_staff: return True person = get_person(request) if person is not None: self.message = _( "You're not allowed to edit this recording.") return obj.person == person self.message = _("Reading recording is not allowed.") return False
def get_queryset(self): person = get_person(self.request) qs = AudioFileTranscription.objects\ .filter(uploaded_by=person)\ .order_by('-updated') # .annotate(num_segments=Count('transcriptionsegment'))\ => takes too # long instead maybe we should delete the "quick test recordings" or # better yet just store them as anonuymous data if we *really* want to # keep it .filter(num_segments__gte=1)\ => prevents us from showing # fresh aft return qs
def test_func(self): person = get_person(self.request) path = self.request.get_full_path() pk = int(path.split('/')[-1]) if self.request.user.is_staff: return True elif person.groups.filter(pk__in=[pk]).exists(): return True else: return False
def get_context_data(self, **kwargs): context = super(SentenceListView, self).get_context_data(**kwargs) user = self.request.user person = get_person(self.request) user.can_approve = user.is_staff and user.is_authenticated() ct = ContentType.objects.get(model='sentence') context['content_type'] = ct.id context['user'] = user context['person'] = person context['uuid'] = self.request.get_signed_cookie('uuid', 'none') return context
def get_context_data(self, **kwargs): context = super(DashboardView, self).get_context_data(**kwargs) person = get_person(self.request) try: token = Token.objects.get(user=person.user) context['token'] = token.key except ObjectDoesNotExist: pass return context
def has_permission(self, request, view): person = get_person(request) if request.method in permissions.SAFE_METHODS: if request.user.is_staff: return True elif person is not None: return request.user.is_authenticated return False else: if request.method in ['PUT']: return request.user.is_authenticated return False
def run_validation(self, data): d2 = None if 'person' in data.keys(): if data['person'] == 'self': d2 = data.copy() person = get_person(self.context['request']) if person is not None: d2['person'] = person.id else: d2['person'] = None if d2 is None: d2 = data return super(SetPersonFromTokenWhenSelf, self).run_validation(d2)
def test_func(self): person = get_person(self.request) aft = self.get_object() key = self.request.GET.get('key', '') if key == '720031ba-4db3-11e8-88f9-8c8590055544': return True if self.request.user.is_staff: return True else: return person == aft.uploaded_by
def has_object_permission(self, request, view, obj): person = get_person(request) if request.method in permissions.SAFE_METHODS: self.message = _("Only staff can read transcriptions.") if request.user.is_staff: person = get_person(request) cache.set( '{0}:{0}:listen'.format(person.uuid, obj.recording.id), True, 15) return True elif person is not None: # Allow people to get their own transcriptions. return person == obj.recording.person else: if request.method in ['PUT']: if request.user.is_staff: return True if person is not None: self.message = _( "You're not allowed to edit this transcription.") return person == obj.recording.person self.message = _("Reading transcriptions is not allowed.") return False
def has_object_permission(self, request, view, obj): person = get_person(request) if request.method in permissions.SAFE_METHODS: if request.user.is_staff: return True elif person is not None: return person == obj.parent.uploaded_by else: if request.method in ['PUT']: if request.user.is_staff: return True if person is not None: return person == obj.parent.uploaded_by return False
def has_object_permission(self, request, view, obj): if request.method in permissions.SAFE_METHODS: # We can create a short lived token here to allow someone to access # the file URL. We will need to store in the cache framework. person = get_person(request) key = '{0}:{0}:listen'.format(person.uuid, obj.id) cache.set(key, True, 15) # logger.debug(' CACHE KEY: {0}'.format(key)) return True else: self.message = _("{0} not allowed with this API\ endpoint.".format(request.method)) return False
def approve_sentence(request, sentence): person = get_person(request) try: qc = SentenceQualityControl.objects.create( person=person, approved=True, approved_by=request.user, notes='Approved in bulk using the admin page.', sentence=sentence, # object_id=sentence.pk, # content_type=ContentType.objects.get_for_model(sentence) ) except: return False return True
def create(self, validated_data): person = get_person(self.context['request']) try: current_license = License.objects\ .get(sitelicense__site=settings.SITE_ID) except ObjectDoesNotExist: return None accept_license, created = \ AcceptLicense.objects.get_or_create(person=person) accept_license.license.add(current_license) accept_license.save() return accept_license
def has_object_permission(self, request, view, obj): person = get_person(request) if request.method in permissions.SAFE_METHODS: if request.user.is_staff: return True elif person is not None: # Allow people to get their own TS objects. return person == obj.uploaded_by else: if request.method in ['PUT', 'DELETE']: if request.user.is_staff: return True if person is not None: return person == obj.uploaded_by return False
def has_permission(self, request, view): person = get_person(request) if request.method in permissions.SAFE_METHODS: if request.user.is_staff: return True elif person is not None: return request.user.is_authenticated return False # return request.user.is_staff else: # Anyone can post a transcription if request.method in ['POST', 'PUT', 'DELETE']: return request.user.is_authenticated return False
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 create(self, validated_data): request = self.context['request'] validated_data['uploaded_by'] = get_person(request) method = request.GET.get('method', '') if 'stream' in method: logger.debug(type(validated_data['audio_file'])) result = transcribe_audio_quick(validated_data['audio_file']) text = result['transcription'].strip() validated_data['transcription'] = text if 'name' not in validated_data.keys(): fname = validated_data['audio_file'].name validated_data['name'] = ''.join(fname.split('.')[:-1]) return super(AudioFileTranscriptionSerializer, self).create(validated_data)
def create(self, validated_data): # This sets a person even when you don't say person=self try: person = validated_data['person'] if person is None: raise KeyError except KeyError: person = get_person(self.context['request']) if person is not None: validated_data['person'] = person recording = \ super(RecordingSerializerPost, self).create(validated_data) # result = transcribe_audio(recording, validated_data['audio_file']) return recording
def get_queryset(self): person = get_person(self.request) # Don't listen to one's own recording queryset = Recording.objects\ .exclude(person=person) # Exclude all approved recordings queryset = queryset\ .annotate(num_approved=Sum( Case( When( quality_control__isnull=True, then=Value(0)), When( quality_control__approved=True, then=Value(1)), When( quality_control__approved=False, then=Value(0)), default=Value(0), output_field=IntegerField()))) queryset = queryset.exclude(num_approved__gte=1) # Exclude items you already listened to queryset = queryset.exclude(quality_control__person=person) sort_by = self.request.query_params.get('sort_by', '') # Let's just get a random recording. ''' queryset = queryset\ .annotate(num_qc=Count('quality_control'))\ .order_by('num_qc') ''' if 'random' in sort_by.lower(): count = queryset.count() if count > 1: i = random.randint(0, count - 1) return [queryset[i]] return queryset
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(self, request, *args, **kwargs): m = get_object_or_404(Recording, pk=kwargs['pk']) u = request.user p = get_person(request) audio_file = m.audio_file if m.audio_file_aac: audio_file = m.audio_file_aac key = '{0}:{0}:listen'.format(p.uuid, m.id) access = cache.get(key) # logger.debug('CAN VIEW: {0} {1}'.format(key, access)) if (u.is_authenticated() and u.is_staff) or (p == m.person) or (access): try: url = audio_file.path url = audio_file.url except: try: url = self.get_redirect_url(filepath=audio_file.name) except: url = audio_file.url if url: if self.permanent: return http.HttpResponsePermanentRedirect(url) else: return http.HttpResponseRedirect(url) else: logger.warning('Gone: %s', self.request.path, extra={ 'status_code': 410, 'request': self.request }) return http.HttpResponseGone() else: raise http.Http404
def has_object_permission(self, request, view, obj): if request.user.is_staff and request.user.is_authenticated: # Authenticated staff have full access return True else: person = get_person(request) if person == obj: # Only a person can view/edit his/her own data if request.method in permissions.SAFE_METHODS: # No authentication needed to view data return True elif request.method in ['POST', 'PUT']: return True # No longer requiring authentication # Authentication needed to edit data self.message = _("You must sign in to edit your info.") return request.user.is_authenticated else: self.message = _("You're not allowed to view this information.") return False self.message = _("You're not allowed to view this information.") return False
def get_changeform_initial_data(self, request): person = get_person(request) return {'uploaded_by': person.id}