def match_up_files(request): available_storage = get_list_or_404(filter_by_access(request.user, Storage, manage=True).order_by('title').values_list('id', 'title')) available_collections = get_list_or_404(filter_by_access(request.user, Collection, manage=True)) class MatchUpForm(forms.Form): collection = forms.ChoiceField(choices=((c.id, c.title) for c in sorted(available_collections, key=lambda c: c.title))) storage = forms.ChoiceField(choices=available_storage) if request.method == 'POST': form = MatchUpForm(request.POST) if form.is_valid(): collection = get_object_or_404(filter_by_access(request.user, Collection.objects.filter(id=form.cleaned_data['collection']), manage=True)) storage = get_object_or_404(filter_by_access(request.user, Storage.objects.filter(id=form.cleaned_data['storage']), manage=True)) job = JobInfo.objects.create(owner=request.user, func='storage_match_up_media', arg=simplejson.dumps(dict( collection=collection.id, storage=storage.id))) job.run() request.user.message_set.create(message='Match up media job has been submitted.') return HttpResponseRedirect("%s?highlight=%s" % (reverse('workers-jobs'), job.id)) else: form = MatchUpForm(request.GET) return render_to_response('storage_match_up_files.html', {'form': form, }, context_instance=RequestContext(request))
def find_records_without_media(request): available_storage = get_list_or_404(filter_by_access(request.user, Storage, manage=True).order_by('title').values_list('id', 'title')) available_collections = get_list_or_404(filter_by_access(request.user, Collection, manage=True)) class SelectionForm(forms.Form): collection = forms.ChoiceField(choices=((c.id, c.title) for c in sorted(available_collections, key=lambda c: c.title))) storage = forms.ChoiceField(choices=available_storage) identifiers = records = [] analyzed = False if request.method == 'POST': form = SelectionForm(request.POST) if form.is_valid(): collection = get_object_or_404(filter_by_access(request.user, Collection.objects.filter(id=form.cleaned_data['collection']), manage=True)) storage = get_object_or_404(filter_by_access(request.user, Storage.objects.filter(id=form.cleaned_data['storage']), manage=True)) records = analyze_records(collection, storage) analyzed = True identifiers = FieldValue.objects.filter(field__in=standardfield('identifier', equiv=True), record__in=records).order_by('value').values_list('value', flat=True) else: form = SelectionForm(request.GET) return render_to_response('storage_find_records_without_media.html', {'form': form, 'identifiers': identifiers, 'records': records, 'analyzed': analyzed, }, context_instance=RequestContext(request))
def match_up_files(request): available_storage = get_list_or_404( filter_by_access(request.user, Storage, manage=True).order_by('title').values_list( 'id', 'title')) available_collections = get_list_or_404( filter_by_access(request.user, Collection, manage=True)) class MatchUpForm(forms.Form): collection = forms.ChoiceField(choices=( (c.id, c.title) for c in sorted(available_collections, key=lambda c: c.title))) storage = forms.ChoiceField(choices=available_storage) if request.method == 'POST': form = MatchUpForm(request.POST) if form.is_valid(): collection = get_object_or_404( filter_by_access(request.user, Collection.objects.filter( id=form.cleaned_data['collection']), manage=True)) storage = get_object_or_404( filter_by_access( request.user, Storage.objects.filter(id=form.cleaned_data['storage']), manage=True)) matches = match_up_media(storage, collection) for record, filename in matches: id = os.path.splitext(os.path.split(filename)[1])[0] mimetype = mimetypes.guess_type( filename)[0] or 'application/octet-stream' media = Media.objects.create(record=record, name=id, storage=storage, url=filename, mimetype=mimetype) request.user.message_set.create( message='%s files were matched up with existing records.' % len(matches)) return HttpResponseRedirect( '%s?collection=%s&storage=%s' % (reverse('storage-match-up-files'), collection.id, storage.id)) else: form = MatchUpForm(request.GET) return render_to_response('storage_match_up_files.html', { 'form': form, }, context_instance=RequestContext(request))
def _get_record_and_media(self, request, id, mediaid=None): record = Record.get_or_404(id, request.user) storages = filter_by_access(request.user, Storage) media = record.media_set.filter(storage__in=filter_by_access(request.user, Storage), mimetype__in=self._supported_mimetypes).order_by('bitrate') if mediaid: media = media.filter(id=mediaid) media = filter(lambda m: self._check_playable(request.user, m), media) if not media: raise Http404() return (record, media)
def filter_by_access(user, *ids): records = Record.objects.distinct() ids = map(int, ids) if user: if user.is_superuser: return records.filter(id__in=ids) accessible_records = cache_get_many( ['record-access-%d-%d' % (user.id or 0, id) for id in ids], model_dependencies=[Record, Collection, AccessControl] ) accessible_record_ids = map(lambda (k, v): (int(k.rsplit('-', 1)[1]), v), accessible_records.iteritems()) allowed_ids = [k for k, v in accessible_record_ids if v == 't'] denied_ids = [k for k, v in accessible_record_ids if v == 'f'] to_check = [id for id in ids if not id in allowed_ids and not id in denied_ids] if not to_check: return records.filter(id__in=allowed_ids) else: allowed_ids = [] to_check = ids # check which records have individual ACLs set individual = _records_with_individual_acl_by_ids(to_check) if individual: allowed_ids.extend(filter_by_access(user, Record.objects.filter(id__in=individual)).values_list('id', flat=True)) to_check = [id for id in to_check if not id in individual] # check records without individual ACLs if to_check: cq = Q(collectionitem__collection__in=filter_by_access(user, Collection), collectionitem__hidden=False) mq = Q(collectionitem__collection__in=filter_by_access(user, Collection, write=True), owner=None) oq = Q(owner=user) if user and not user.is_anonymous() else Q() records = records.filter(cq | mq | oq) checked = records.filter(id__in=to_check).values_list('id', flat=True) allowed_ids.extend(checked) if user: cache_update = dict( ('record-access-%d-%d' % (user.id or 0, id), 't' if id in checked else 'f') for id in to_check ) cache_set_many(cache_update, model_dependencies=[Record, Collection, AccessControl]) return records.filter(id__in=allowed_ids)
def manage(request): storage_manage = filter_by_access(request.user, Storage, manage=True).count() > 0 storage_write = filter_by_access(request.user, Storage, write=True).count() > 0 collection_write = filter_by_access(request.user, Collection, write=True).count() > 0 collection_manage = filter_by_access(request.user, Collection, manage=True).count() > 0 return render_to_response('ui_management.html', {'storage_manage': storage_manage, 'storage_write': storage_write, 'collection_write': collection_write, 'collection_manage': collection_manage, }, context_instance=RequestContext(request))
def powerpoint(request): available_storage = get_list_or_404(filter_by_access(request.user, Storage, write=True).order_by('title').values_list('id', 'title')) available_collections = get_list_or_404(filter_by_access(request.user, Collection, write=True).order_by('title').values_list('id', 'title')) class UploadFileForm(forms.Form): title = forms.CharField(max_length=50) storage = forms.ChoiceField(choices=available_storage) collection = forms.ChoiceField(choices=available_collections) file = forms.FileField() def clean_file(self): file = self.cleaned_data['file'] if not file.content_type in ('application/vnd.ms-powerpoint', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'): raise forms.ValidationError("The selected file does not appear to be a PowerPoint file") return file if request.method == 'POST': form = UploadFileForm(request.POST, request.FILES) if form.is_valid(): tempdir = tempfile.mkdtemp() infile = form.cleaned_data['file'] filename = os.path.join(tempdir, 'a.ppt' if infile.content_type == 'application/vnd.ms-powerpoint' else 'a.pptx') outfile = open(filename, "wb+") for chunk in infile.chunks(): outfile.write(chunk) outfile.close() presentation = convert_ppt(request.user, form.cleaned_data['title'], Collection.objects.get(id=form.cleaned_data['collection'], id__in=accessible_ids(request.user, Collection, write=True)), Storage.objects.get(id=form.cleaned_data['storage'], id__in=accessible_ids(request.user, Storage, write=True)), tempdir, filename) shutil.rmtree(tempdir) if not presentation: request.user.message_set.create(message="An error occurred while importing the presentation.") else: request.user.message_set.create(message="Presentation created successfully.") return HttpResponseRedirect(reverse('presentation-edit', kwargs=dict(id=presentation.id, name=presentation.name))) else: form = UploadFileForm() return render_to_response('powerpoint.html', {'form': form}, context_instance=RequestContext(request))
def match_up_files(request): available_storage = get_list_or_404( filter_by_access(request.user, Storage, manage=True).order_by('title').values_list( 'id', 'title')) available_collections = get_list_or_404( filter_by_access(request.user, Collection, manage=True)) class MatchUpForm(forms.Form): collection = forms.ChoiceField(choices=( (c.id, c.title) for c in sorted(available_collections, key=lambda c: c.title))) storage = forms.ChoiceField(choices=available_storage) if request.method == 'POST': form = MatchUpForm(request.POST) if form.is_valid(): collection = get_object_or_404( filter_by_access(request.user, Collection.objects.filter( id=form.cleaned_data['collection']), manage=True)) storage = get_object_or_404( filter_by_access( request.user, Storage.objects.filter(id=form.cleaned_data['storage']), manage=True)) job = JobInfo.objects.create(owner=request.user, func='storage_match_up_media', arg=simplejson.dumps( dict(collection=collection.id, storage=storage.id))) job.run() request.user.message_set.create( message='Match up media job has been submitted.') return HttpResponseRedirect("%s?highlight=%s" % (reverse('workers-jobs'), job.id)) else: form = MatchUpForm(request.GET) return render_to_response('storage_match_up_files.html', { 'form': form, }, context_instance=RequestContext(request))
def view(self, request, template='audiotextsync_view.html'): next = request.GET.get('next') can_edit = self.obj.editable_by(request.user) textmedia = audiomedia = None for media in self.obj.media_set.filter( storage__in=filter_by_access(request.user, Storage)): if not audiomedia and media.mimetype == 'audio/mpeg': audiomedia = media elif not textmedia and media.mimetype == 'text/plain': textmedia = media if not textmedia or not audiomedia: raise Http404() transcript = textmedia.load_file().readlines() markers = get_markers(self.obj) return render_to_response(template, {'record': self.obj, 'next': next, 'transcript': transcript, 'markers': dict(map(lambda v: v.split(','), markers.value.split())) if markers.value else dict(), 'mp3url': audiomedia.get_absolute_url(), 'edit': can_edit, }, context_instance=RequestContext(request))
def view(self, request, id, name, template="audiotextsync/audiotextsync.html"): next = request.GET.get("next") record, can_edit = self._get_record_and_access(request, id, name) storages = filter_by_access(request.user, Storage) textmedia = audiomedia = None for media in record.media_set.filter(storage__in=storages): if not audiomedia and media.mimetype == "audio/mpeg": audiomedia = media elif not textmedia and media.mimetype == "text/plain": textmedia = media if not textmedia or not audiomedia: raise Http404() transcript = textmedia.load_file().readlines() markers = self._get_markers(record) return render_to_response( template, { "record": record, "next": next, "transcript": transcript, "markers": dict(map(lambda v: v.split(","), markers.value.split())) if markers.value else dict(), "mp3url": audiomedia.get_absolute_url(), "edit": can_edit, }, context_instance=RequestContext(request), )
def find_in_db(request, collection_id=None, field_id=None, value=None): collection = collection_id and get_object_or_404(filter_by_access(request.user, Collection), id=collection_id) or None if field_id: field = get_object_or_404(Field, id=field_id) if request.method == "POST": raise NotImplementedError("Can't post to find_in_db") user = request.user record_ids = FieldValue.objects.filter(field=field, value=value, record__collection=collection).values_list('record', flat=True) records = Record.objects.filter(id__in=record_ids).values_list('tmp_extthumb', 'name', 'source') keys = ['thumb_url', 'title', 'record_url'] dicts = [] for value_set in records: dicts.append(dict(zip(keys,value_set))) related_pages = [{"url": 'solr-browse', "title": "Back to Browse"}] return render_to_response('searcher-results.html', {'results': dicts, 'hits': len(records), # TODO, make this use count (more efficient) 'browse': True, 'searcher_name': collection}, context_instance=RequestContext(request))
def password(request, id, name): presentation = get_object_or_404( filter_by_access(request.user, Presentation).filter( Presentation.published_Q(request.user), id=id)) class PasswordForm(forms.Form): password = forms.CharField(widget=forms.PasswordInput) def clean_password(self): p = self.cleaned_data.get('password') if p != presentation.password: raise forms.ValidationError("Password is not correct.") return p if request.method == 'POST': form = PasswordForm(request.POST) if form.is_valid(): request.session.setdefault( 'passwords', dict())[presentation.id] = form.cleaned_data.get('password') request.session.modified = True return HttpResponseRedirect( request.GET.get('next', reverse('presentation-browse'))) else: form = PasswordForm() return render_to_response( 'presentation_password.html', { 'form': form, 'presentation': presentation, 'next': request.GET.get('next', reverse('presentation-browse')), }, context_instance=RequestContext(request))
def interview(request, number): collection = Collection.objects.get(name='shenandoah-national-park') record = get_object_or_404(FieldValue, record__collection=collection, field__label='Identifier', value=number).record description = FieldValue.objects.filter( record=record, field__label='Description', ).values_list('value', flat=True) storages = filter_by_access(request.user, Storage) media = record.media_set.filter(storage__in=storages) images = filter(lambda m: m.mimetype == 'image/jpeg', media) atsviewer = audiotextsyncviewer(record, request) return render_to_response( 'snp-interview.html', { 'record': record, 'description': description[0] if description else None, 'interview_number': number, 'has_audio_transcript': atsviewer, 'has_media': len(media) > 0, 'images': images, }, context_instance=RequestContext(request))
def interview(request, number): collection = Collection.objects.get(name='shenandoah-national-park') record = get_object_or_404(FieldValue, record__collection=collection, field__label='Identifier', value=number).record description = FieldValue.objects.filter(record=record, field__label='Description', ).values_list('value', flat=True) storages = filter_by_access(request.user, Storage) media = record.media_set.filter(storage__in=storages) images = filter(lambda m: m.mimetype == 'image/jpeg', media) atsviewer = audiotextsyncviewer(record, request) return render_to_response('snp-interview.html', {'record': record, 'description': description[0] if description else None, 'interview_number': number, 'has_audio_transcript': atsviewer, 'has_media': len(media) > 0, 'images': images, }, context_instance=RequestContext(request))
def media(request, number): LABELS = { 'application/pdf': 'View PDF', 'image/jpeg': 'View Image', 'text/plain': 'View Text', 'audio/mpeg': 'Listen to Audio', } collection = Collection.objects.get(name='shenandoah-national-park') record = get_object_or_404(FieldValue, record__collection=collection, field__label='Identifier', value=number).record storages = filter_by_access(request.user, Storage) media = record.media_set.filter(storage__in=storages).order_by('mimetype') labels = [LABELS.get(m.mimetype, 'Download file') for m in media] return render_to_response('snp-media.html', {'record': record, 'interview_number': number, 'media': zip(media, labels), }, context_instance=RequestContext(request))
def password(request, id, name): presentation = get_object_or_404( filter_by_access(request.user, Presentation).filter( Presentation.published_Q(request.user), id=id)) class PasswordForm(forms.Form): password = forms.CharField(widget=forms.PasswordInput) def clean_password(self): p = self.cleaned_data.get('password') if p != presentation.password: raise forms.ValidationError("Password is not correct.") return p if request.method == 'POST': form = PasswordForm(request.POST) if form.is_valid(): request.session.setdefault('passwords', dict())[presentation.id] = form.cleaned_data.get('password') request.session.modified = True return HttpResponseRedirect(request.GET.get('next', reverse('presentation-browse'))) else: form = PasswordForm() return render_to_response('presentation_password.html', {'form': form, 'presentation': presentation, 'next': request.GET.get('next', reverse('presentation-browse')), }, context_instance=RequestContext(request))
def duplicate(request, id, name): presentation = get_object_or_404( filter_by_access(request.user, Presentation, write=True, manage=True).filter(id=id)) dup = duplicate_presentation(presentation, request.user) return HttpResponseRedirect( reverse('presentation-edit', args=(dup.id, dup.name)))
def manage_collections(request): collections = filter_by_access(request.user, Collection, manage=True) return render_to_response( "data_manage_collections.html", {"collections": collections}, context_instance=RequestContext(request) )
def media(request, number): LABELS = { 'application/pdf': 'View PDF', 'image/jpeg': 'View Image', 'text/plain': 'View Text', 'audio/mpeg': 'Listen to Audio', } collection = Collection.objects.get(name='shenandoah-national-park') record = get_object_or_404(FieldValue, record__collection=collection, field__label='Identifier', value=number).record storages = filter_by_access(request.user, Storage) media = record.media_set.filter(storage__in=storages).order_by('mimetype') labels = [LABELS.get(m.mimetype, 'Download file') for m in media] return render_to_response('snp-media.html', { 'record': record, 'interview_number': number, 'media': zip(media, labels), }, context_instance=RequestContext(request))
def overview(request): collections = filter_by_access(request.user, Collection) collections = apply_collection_visibility_preferences(request.user, collections) collections = collections.order_by("title").annotate(num_records=Count("records")) return render_to_response("overview.html", {"collections": collections}, context_instance=RequestContext(request))
def duplicate(request, id, name): presentation = get_object_or_404( filter_by_access(request.user, Presentation, write=True, manage=True). filter(id=id)) dup = duplicate_presentation(presentation, request.user) return HttpResponseRedirect(reverse('presentation-edit', args=(dup.id, dup.name)))
def overview(request): collections = filter_by_access(request.user, Collection).order_by('title').annotate(num_records=Count('records')) return render_to_response('overview.html', {'collections': collections,}, context_instance=RequestContext(request))
def powerpoint(request): available_storage = get_list_or_404(filter_by_access(request.user, Storage, write=True).order_by('title').values_list('id', 'title')) available_collections = get_list_or_404(filter_by_access(request.user, Collection, write=True).order_by('title').values_list('id', 'title')) class UploadFileForm(forms.Form): title = forms.CharField(max_length=50) storage = forms.ChoiceField(choices=available_storage) collection = forms.ChoiceField(choices=available_collections) file = forms.FileField() def clean_file(self): file = self.cleaned_data['file'] if not file.content_type in ('application/vnd.ms-powerpoint', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'): raise forms.ValidationError("The selected file does not appear to be a PowerPoint file") return file if request.method == 'POST': form = UploadFileForm(request.POST, request.FILES) if form.is_valid(): tempdir = tempfile.mkdtemp() infile = form.cleaned_data['file'] filename = os.path.join(tempdir, 'a.ppt' if infile.content_type == 'application/vnd.ms-powerpoint' else 'a.pptx') outfile = open(filename, "wb+") for chunk in infile.chunks(): outfile.write(chunk) outfile.close() presentation = convert_ppt(request.user, form.cleaned_data['title'], filter_by_access(request.user, Collection, write=True).get(id=form.cleaned_data['collection']), filter_by_access(request.user, Storage, write=True).get(id=form.cleaned_data['storage']), tempdir, filename) shutil.rmtree(tempdir) if not presentation: request.user.message_set.create(message="An error occurred while importing the presentation.") else: request.user.message_set.create(message="Presentation created successfully.") return HttpResponseRedirect(reverse('presentation-edit', kwargs=dict(id=presentation.id, name=presentation.name))) else: form = UploadFileForm() return render_to_response('powerpoint.html', {'form': form}, context_instance=RequestContext(request))
def get_media_for_record(recordid, user=None, passwords={}): """ Returns all media accessible to the user either directly through collections or indirectly through presentations. A user always must have access to the storage where the media is stored. """ from rooibos.presentation.models import Presentation print str(recordid) #record_id = getattr(record, 'id', record) print 'recordid '+ str(recordid) if isinstance(recordid, Record): record_id = recordid.id else: record_id = recordid if DEBUG: print "RECORD ID: " + str(record_id) record = Record.filter_one_by_access(user, record_id) if DEBUG: print "record filtered" if not record: print "not record in storage/init/get_media" # Try to get to record through an accessible presentation - # own presentations don't count, since it's already established that owner # doesn't have access to the record. pw_q = Q( # Presentation must not have password Q(password=None) | Q(password='') | # or must know password Q(id__in=Presentation.check_passwords(passwords)) ) access_q = Q( # Must have access to presentation id__in=filter_by_access(user, Presentation), # and presentation must not be archived hidden=False ) accessible_presentations = Presentation.objects.filter( pw_q, access_q, items__record__id=record_id) # Now get all the presentation owners so we can check if any of them have access # to the record owners = User.objects.filter(id__in=accessible_presentations.values('owner')) if not any(Record.filter_one_by_access(owner, record_id) for owner in owners): if DEBUG: print "Media.objects.none() is being returned" return Media.objects.none() #print "how many media objects: "+str(Media.objects.count()) #print "data: "+str(Media.objects.all().values("record__id", "url")) print "media filter filtered" media_filter = Media.objects.filter( record__id=record_id, #storage__id__in=filter_by_access(user, Storage), ) if not media_filter: print "oh no, no media there on line 82 of storage/__init__" print str(Media.objects.all()) print "Count: " + str(Media.objects.count()) return media_filter
def manage_collections(request): collections = filter_by_access(request.user, Collection, manage=True) return render_to_response('data_manage_collections.html', { 'collections': collections, }, context_instance=RequestContext(request))
def accessible_objects(user, args): app_model, access = args.split(',') app, model = app_model.split('.') read = 'r' in access write = 'w' in access manage = 'm' in access return filter_by_access(user, ContentType.objects.get(app_label=app, model=model).model_class(), read, write, manage)
def render(self, context): user = self.user.resolve(context) values = load_settings(user, RECENT_PRESENTATION) presentation = None if values.has_key(RECENT_PRESENTATION): presentation = filter_by_access(user, Presentation, manage=True).filter(id=values[RECENT_PRESENTATION][0]) context[self.var_name] = presentation[0] if presentation else None return ''
def fetch_current_presentation(user): values = load_settings(user, RECENT_PRESENTATION) presentation = None if values.has_key(RECENT_PRESENTATION): presentation = filter_by_access( user, Presentation, manage=True).filter(id=values[RECENT_PRESENTATION][0]) return presentation[0] if presentation else None
def search_facets(request, id=None, name=None, selected=False): collection = get_object_or_404(filter_by_access(request.user, Collection), id=id) if id else None # get parameters relevant for search criteria = request.GET.getlist("c") remove = request.GET.get("rem", None) if remove and remove in criteria: criteria.remove(remove) keywords = request.GET.get("kw", "") user = request.user if selected: selected = request.session.get("selected_records", ()) (hits, records, search_facets, orfacet, query, fields) = run_search( user, collection, criteria, keywords, selected=selected, remove=remove, produce_facets=True ) if collection: url = reverse("solr-search-collection", kwargs={"id": collection.id, "name": collection.name}) elif selected: url = reverse("solr-selected") else: url = reverse("solr-search") q = request.GET.copy() q = clean_record_selection_vars(q) q.pop("or", None) q.pop("rem", None) q.pop("action", None) q.pop("page", None) q.pop("op", None) q.setlist("c", criteria) qurl = q.urlencode() limit_url = "%s?%s%s" % (url, qurl, qurl and "&" or "") # sort facets by label facets = sorted(search_facets.values(), key=lambda f: f.label) # clean facet items for f in facets: f.clean_result(hits) # remove facets with only no filter options facets = filter(lambda f: len(f.facets) > 0, facets) html = render_to_string( "results_facets.html", {"limit_url": limit_url, "facets": facets}, context_instance=RequestContext(request) ) mode, ids = get_collection_visibility_preferences(user) hash = calculate_hash(getattr(user, "id", 0), collection, criteria, keywords, selected, remove, mode, str(ids)) cache.set("search_facets_html_%s" % hash, html, 300) return dict(html=html)
def collections(request, id=None): if id: collections = filter_by_access(request.user, Collection.objects.filter(id=id)) else: collections = filter_by_access(request.user, Collection) return { 'collections': [ dict(id=c.id, name=c.name, title=c.title, owner=c.owner, hidden=c.hidden, description=c.description, agreement=c.agreement, children=list(c.children.all().values_list('id', flat=True)), ) for c in collections] }
def analyze(request, id, name): storage = get_object_or_404(filter_by_access(request.user, Storage.objects.filter(id=id), manage=True)) broken, extra = analyze_media(storage) return render_to_response('storage_analyze.html', {'storage': storage, 'broken': broken, 'extra': extra, }, context_instance=RequestContext(request))
def _check_permission_for_user(self, user, **permissions): # checks if user is owner or has ACL access if check_access(user, self, **permissions): return True # if record does not have individual ACL... if len(_records_with_individual_acl_by_ids([self.id])) > 0: return False # ...check collection access return filter_by_access(user, self.collection_set, **permissions).count() > 0
def overview(request): collections = filter_by_access(request.user, Collection) collections = apply_collection_visibility_preferences(request.user, collections) collections = collections.order_by('title').annotate(num_records=Count('records')) return render_to_response('overview.html', {'collections': collections,}, context_instance=RequestContext(request))
def accessible_objects(user, args): app_model, access = args.split(',') app, model = app_model.split('.') read = 'r' in access write = 'w' in access manage = 'm' in access return filter_by_access( user, ContentType.objects.get(app_label=app, model=model).model_class(), read, write, manage)
def analyze(request, id, name, allow_multiple_use=True): storage = get_object_or_404(filter_by_access(request.user, Storage.objects.filter(id=id), manage=True)) broken, extra = analyze_media(storage, allow_multiple_use) broken = [m.url for m in broken] return render_to_response('storage_analyze.html', {'storage': storage, 'broken': sorted(broken), 'extra': sorted(extra), }, context_instance=RequestContext(request))
def published_Q(owner=None): publish_permission = Permission.objects.get(codename='publish_presentations') valid_publishers = User.objects.filter(Q(id__in=publish_permission.user_set.all()) | Q(groups__id__in=publish_permission.group_set.all()) | Q(is_superuser=True)) q = Q(owner__in=valid_publishers) & Q(hidden=False) if owner and not owner.is_anonymous(): return q | Q(id__in=filter_by_access(owner, Presentation, manage=True)) else: return q
def get_media_for_record(record, user=None, passwords={}): """ Returns all media accessible to the user either directly through collections or indirectly through presentations. A user always must have access to the storage where the media is stored. """ from rooibos.presentation.models import Presentation record_id = getattr(record, 'id', record) record = Record.filter_one_by_access(user, record_id) if not record: print "Media is not a record" # Try to get to record through an accessible presentation - # own presentations don't count, since it's already established that owner # doesn't have access to the record. pw_q = Q( # Presentation must not have password Q(password=None) | Q(password='') | # or must know password Q(id__in=Presentation.check_passwords(passwords)) ) access_q = Q( # Must have access to presentation id__in=filter_by_access(user, Presentation), # and presentation must not be archived hidden=False ) accessible_presentations = Presentation.objects.filter( pw_q, access_q, items__record__id=record_id) # Now get all the presentation owners so we can check if any of them have access # to the record owners = User.objects.filter(id__in=accessible_presentations.values('owner')) if not any(Record.filter_one_by_access(owner, record_id) for owner in owners): return Media.objects.none() print record_id print filter_by_access(user, Storage) return Media.objects.filter( record__id=record_id, storage__id__in=filter_by_access(user, Storage), )
def media_upload_form(request): available_storage = filter_by_access(request.user, Storage, write=True).order_by('title').values_list('name','title') if not available_storage: return None class UploadFileForm(forms.Form): storage = forms.ChoiceField(choices=available_storage) file = forms.FileField() return UploadFileForm
def browse(request, id=None, name=None): collections = filter_by_access(request.user, Collection) collections = apply_collection_visibility_preferences(request.user, collections) collections = collections.annotate(num_records=Count('records')).filter(num_records__gt=0).order_by('title') if not collections: return render_to_response('browse.html', {}, context_instance=RequestContext(request)) if request.GET.has_key('c'): collection = get_object_or_404(collections, name=request.GET['c']) return HttpResponseRedirect(reverse('solr-browse-collection', kwargs={'id': collection.id, 'name': collection.name})) collection = id and get_object_or_404(collections, id=id) or collections[0] fields = cache.get('browse_fields_%s' % collection.id) if fields: fields = list(Field.objects.filter(id__in=fields)) else: fields = list(Field.objects.filter(fieldvalue__record__collection=collection).distinct()) cache.set('browse_fields_%s' % collection.id, [f.id for f in fields], 60) if not fields: raise Http404() if request.GET.has_key('f'): try: field = get_object_or_404(Field, id=request.GET['f'], id__in=(f.id for f in fields)) except ValueError: # GET['f'] was text previously and external links exist that are no longer valid return HttpResponseRedirect(reverse('solr-browse-collection', kwargs={'id': collection.id, 'name': collection.name})) else: field = fields[0] values = FieldValue.objects.filter(field=field, record__collection=collection).values('value').annotate(freq=Count('value', distinct=False)).order_by('value') #print "solr.views 741 collection %s field %s manager %s" %(collection, field.__class__.__name__, FieldValue.objects) if request.GET.has_key('s'): start = values.filter(value__lt=request.GET['s']).count() / 50 + 1 return HttpResponseRedirect(reverse('solr-browse-collection', kwargs={'id': collection.id, 'name': collection.name}) + "?f=%s&page=%s" % (field.id, start)) return render_to_response('browse.html', {'collections': collections, 'selected_collection': collection and collection or None, 'fields': fields, 'selected_field': field, 'values': values,}, context_instance=RequestContext(request))
def manage_storages(request): storages = filter_by_access(request.user, Storage, manage=True).order_by('title') for s in storages: s.analysis_available = hasattr(s, 'get_files') return render_to_response('storage_manage.html', {'storages': storages, }, context_instance=RequestContext(request))
def browse(request, id=None, name=None): collections = filter_by_access(request.user, Collection) collections = apply_collection_visibility_preferences(request.user, collections) collections = collections.annotate(num_records=Count('records')).filter(num_records__gt=0).order_by('title') if not collections: return render_to_response('browse.html', {}, context_instance=RequestContext(request)) if request.GET.has_key('c'): collection = get_object_or_404(collections, name=request.GET['c']) return HttpResponseRedirect(reverse('solr-browse-collection', kwargs={'id': collection.id, 'name': collection.name})) collection = id and get_object_or_404(collections, id=id) or collections[0] fields = cache.get('browse_fields_%s' % collection.id) if fields: fields = list(Field.objects.filter(id__in=fields)) else: fields = list(Field.objects.filter(fieldvalue__record__collection=collection).distinct()) cache.set('browse_fields_%s' % collection.id, [f.id for f in fields], 60) if not fields: raise Http404() if request.GET.has_key('f'): try: field = get_object_or_404(Field, id=request.GET['f'], id__in=(f.id for f in fields)) except ValueError: # GET['f'] was text previously and external links exist that are no longer valid return HttpResponseRedirect(reverse('solr-browse-collection', kwargs={'id': collection.id, 'name': collection.name})) else: field = fields[0] values = FieldValue.objects.filter(field=field, record__collection=collection).values('value').annotate(freq=Count('value', distinct=False)).order_by('value') print "solr.views 741 collection %s field %s manager %s" %(collection, field.__class__.__name__, FieldValue.objects) if request.GET.has_key('s'): start = values.filter(value__lt=request.GET['s']).count() / 50 + 1 return HttpResponseRedirect(reverse('solr-browse-collection', kwargs={'id': collection.id, 'name': collection.name}) + "?f=%s&page=%s" % (field.id, start)) return render_to_response('browse.html', {'collections': collections, 'selected_collection': collection and collection or None, 'fields': fields, 'selected_field': field, 'values': values,}, context_instance=RequestContext(request))
def match_up_files(request): available_storage = get_list_or_404(filter_by_access(request.user, Storage, manage=True).order_by('title').values_list('id', 'title')) available_collections = get_list_or_404(filter_by_access(request.user, Collection, manage=True)) class MatchUpForm(forms.Form): collection = forms.ChoiceField(choices=((c.id, c.title) for c in sorted(available_collections, key=lambda c: c.title))) storage = forms.ChoiceField(choices=available_storage) if request.method == 'POST': form = MatchUpForm(request.POST) if form.is_valid(): collection = get_object_or_404(filter_by_access(request.user, Collection.objects.filter(id=form.cleaned_data['collection']), manage=True)) storage = get_object_or_404(filter_by_access(request.user, Storage.objects.filter(id=form.cleaned_data['storage']), manage=True)) matches = match_up_media(storage, collection) for record, filename in matches: id = os.path.splitext(os.path.split(filename)[1])[0] mimetype = mimetypes.guess_type(filename)[0] or 'application/octet-stream' media = Media.objects.create(record=record, name=id, storage=storage, url=filename, mimetype=mimetype) request.user.message_set.create(message='%s files were matched up with existing records.' % len(matches)) return HttpResponseRedirect('%s?collection=%s&storage=%s' % ( reverse('storage-match-up-files'), collection.id, storage.id )) else: form = MatchUpForm(request.GET) return render_to_response('storage_match_up_files.html', {'form': form, }, context_instance=RequestContext(request))
def media_upload_form(request): available_storage = filter_by_access(request.user, Storage, write=True).order_by('title') if not available_storage: return None choices = [make_storage_select_choice(s, request.user) for s in available_storage] class UploadFileForm(forms.Form): storage = forms.ChoiceField(choices=choices) file = forms.FileField() return UploadFileForm
def get_media_for_record(record, user=None, passwords={}): """ Returns all media accessible to the user either directly through collections or indirectly through presentations. A user always must have access to the storage where the media is stored. """ from rooibos.presentation.models import Presentation record_id = getattr(record, 'id', record) record = Record.filter_one_by_access(user, record_id) if not record: # Try to get to record through an accessible presentation - # own presentations don't count, since it's already established that owner # doesn't have access to the record. pw_q = Q( # Presentation must not have password Q(password=None) | Q(password='') | # or must know password Q(id__in=Presentation.check_passwords(passwords))) access_q = Q( # Must have access to presentation id__in=filter_by_access(user, Presentation), # and presentation must not be archived hidden=False) accessible_presentations = Presentation.objects.filter( pw_q, access_q, items__record__id=record_id) # Now get all the presentation owners so we can check if any of them have access # to the record owners = User.objects.filter( id__in=accessible_presentations.values('owner')) if not any( Record.filter_one_by_access(owner, record_id) for owner in owners): return Media.objects.none() return Media.objects.filter( record__id=record_id, storage__id__in=filter_by_access(user, Storage), )
def published_Q(owner=None): publish_permission = Permission.objects.get( codename='publish_presentations') valid_publishers = User.objects.filter( Q(id__in=publish_permission.user_set.all()) | Q(groups__id__in=publish_permission.group_set.all()) | Q(is_superuser=True)) q = Q(owner__in=valid_publishers) & Q(hidden=False) if owner and not owner.is_anonymous(): return q | Q( id__in=filter_by_access(owner, Presentation, manage=True)) else: return q
def manage_storage(request, storageid=None, storagename=None): if storageid and storagename: storage = get_object_or_404(filter_by_access(request.user, Storage, manage=True), id=storageid) else: storage = Storage(system='local') if not storage.id: system_choices = [(s, s) for s in settings.STORAGE_SYSTEMS.keys()] else: system_choices = [(storage.system, storage.system)] class StorageForm(forms.ModelForm): system = forms.CharField(widget=forms.Select(choices=system_choices)) def clean_system(self): return self.cleaned_data[ 'system'] if not self.instance.id else self.instance.system class Meta: model = Storage exclude = ('name', 'derivative') if request.method == "POST": if request.POST.get('delete-storage'): if not request.user.is_superuser: raise HttpResponseForbidden() request.user.message_set.create( message="Storage '%s' has been deleted." % storage.title) storage.delete() return HttpResponseRedirect(reverse('storage-manage')) else: form = StorageForm(request.POST, instance=storage) if form.is_valid(): form.save() return HttpResponseRedirect( reverse('storage-manage-storage', kwargs=dict(storageid=form.instance.id, storagename=form.instance.name))) else: form = StorageForm(instance=storage) return render_to_response('storage_edit.html', { 'storage': storage, 'form': form, }, context_instance=RequestContext(request))
def find_in_db(request, collection_id=None, field_id=None, value=None): collection = collection_id and get_object_or_404( filter_by_access(request.user, Collection), id=collection_id) or None if field_id: field = get_object_or_404(Field, id=field_id) if request.method == "POST": raise NotImplementedError("Can't post to find_in_db") user = request.user #values = FieldValue.objects.filter(field=field, value=value, record__collection=collection) record_ids = FieldValue.objects.filter( field=field, value=value, record__collection=collection).values_list('record', flat=True) records = Record.objects.filter( id__in=record_ids) #.values_list('tmp_extthumb', 'name', 'source') keys = ['thumb_url', 'title', 'record_url'] dicts = [] #iterate through the list of records and grab every attribute you need #for r in records: #get all the values and do a reverse lookup of the collection #manually build the dict and then pass it to the searcher-results.html for r in records: thumb_url = r.get_thumbnail_url() title = r.title #get the url for the record? record_location = r.get_absolute_url() record_list = [thumb_url, title, record_location] dicts.append(dict(zip(keys, record_list))) #for value_set in records: # dicts.append(dict(zip(keys,value_set))) related_pages = [{"url": 'solr-browse', "title": "Back to Browse"}] return render_to_response( 'searcher-results.html', { 'results': dicts, 'hits': len(records), # TODO, make this use count (more efficient) 'browse': True, 'searcher_name': collection }, context_instance=RequestContext(request))
def fieldvalue_autocomplete(request): collection_ids = request.GET.get('collections') q = collection_ids and Collection.objects.filter(id__in=collection_ids.split(',')) or Collection collections = filter_by_access(request.user, q) if not collections: raise Http404() query = request.GET.get('q', '').lower() if len(query) >= 2 and len(query) <= 32: limit = min(int(request.GET.get('limit', '10')), 100) field = request.GET.get('field') q = field and Q(field__id=field) or Q() values = FieldValue.objects.filter(q, record__collection__in=collections, index_value__istartswith=query) \ .values_list('value', flat=True).distinct()[:limit] #.order_by('value') #print values.query.as_sql() values = '\n'.join(urlquote(v) for v in values) else: values = '' return HttpResponse(content=values)
def audiotextsyncviewer(obj, request, objid=None): if obj: if not isinstance(obj, Record): return None else: obj = Record.filter_one_by_access(request.user, objid) if not obj: return None has_text = has_audio = False for media in obj.media_set.filter( storage__in=filter_by_access(request.user, Storage)): if media.mimetype == 'audio/mpeg': has_audio = True elif media.mimetype == 'text/plain': has_text = True if not has_text or not has_audio: return None return AudioTextSyncViewer(obj, request.user)
def m_browse(request, manage=False): presenter = request.GET.get('presenter') tags = ["ARTH101", "ARTH102", "ARTH243"] qs = OwnedWrapper.objects.filter(content_type=OwnedWrapper.t(Presentation)) # get list of matching IDs for each individual tag, since tags may be attached by different owners ids = [ list( TaggedItem.objects.get_by_model(qs, '"%s"' % tag).values_list( 'object_id', flat=True)) for tag in tags ] q = [] for x in ids: q.append(Q(id__in=x)) pOut = [] presentations = filter_by_access(request.user, Presentation) i = 0 for x in q: pOut.append( list( presentations.select_related('owner').filter(x).order_by( 'title'))) i += 1 class ACourse(): courseName = "" contents = [] def courseify(name, presentations): c = ACourse() c.courseName = name c.contents = presentations return c courses = map(courseify, tags, pOut) return render_to_response('mobilePresentationList.html', {'courses': courses}, context_instance=RequestContext(request))