def overview(request): collections = filter_by_access(request.user, Collection.objects.exclude(hidden=True)) collections = apply_collection_visibility_preferences( request.user, collections) collections = collections.annotate(num_records=Count('records')) children = dict() overview_thumbs = dict() for coll in collections: c = filter_by_access(request.user, coll.children.exclude(hidden=True)) c = apply_collection_visibility_preferences(request.user, c) children[coll.id] = c for record in Record.objects.filter(id__in=FieldValue.objects.filter( field=get_system_field(), value='overview', index_value='overview', ).values('record'), ): for coll in record.collection_set.all().values_list('id', flat=True): overview_thumbs[coll] = record return render_to_response('overview.html', { 'collections': [(coll, children[coll.id], overview_thumbs.get(coll.id)) for coll in collections] }, 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=json.dumps(dict( collection=collection.id, storage=storage.id))) job.run() messages.success(request, 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 filter_by_access(user, *ids): records = Record.objects.distinct() ids = list(map(int, ids)) if user and user.is_superuser: return records.filter(id__in=ids) 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 id not in individual] # check records without individual ACLs if to_check: readable = filter_by_access(user, Collection) writable = filter_by_access(user, Collection, write=True) cq = Q(collectionitem__collection__in=readable, collectionitem__hidden=False) mq = Q(collectionitem__collection__in=writable, 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) return records.filter(id__in=allowed_ids)
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) allow_multiple_use = forms.BooleanField(required=False) 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, allow_multiple_use=form. cleaned_data['allow_multiple_use']))) job.run() messages.add_message( request, messages.INFO, 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 available_collections)) storage = forms.ChoiceField(choices=available_storage) allow_multiple_use = forms.BooleanField(required=False) 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)) task = storage_match_up_media.delay( owner=request.user.id, collection_id=collection.id, storage_id=storage.id, allow_multiple_use=form.cleaned_data['allow_multiple_use'], ) messages.add_message( request, messages.INFO, message='Match up media job has been submitted.') return HttpResponseRedirect("%s?highlight=%s" % (reverse('workers-jobs'), task.id)) else: form = MatchUpForm(request.GET) return render(request, 'storage_match_up_files.html', { 'form': form, })
def manage_collections(request): collections = filter_by_access(request.user, Collection, manage=True) return render(request, 'data_manage_collections.html', { 'collections': collections, })
def render(self, context): record = self.record.resolve(context) fieldset = self.fieldset.resolve(context) if self.fieldset else None fieldvalues = list( record.get_fieldvalues(owner=context['request'].user, fieldset=fieldset)) crosslinks = self.crosslinks and self.crosslinks.resolve(context) crosslink_fields = dict() if crosslinks: try: crosslink_fields.update( (field.id, None) for field in FieldSet.objects.get( name='metadata-crosslinks').fields.all()) except FieldSet.DoesNotExist: pass for i in range(0, len(fieldvalues)): fieldvalues[i].crosslinked = (crosslinks and fieldvalues[i].value and fieldvalues[i].field_id in crosslink_fields) collections = filter_by_access(context['request'].user, record.collection_set.all()) return render_to_string('data_metadata.html', dict( values=fieldvalues, record=record, collections=collections, ), context_instance=context)
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 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 get_collection_visibility_prefs_form(user): collection_choices = ( (c.id, c.title) for c in filter_by_access(user, Collection) ) class CollectionVisibilityPreferencesForm(forms.Form): show_or_hide = forms.ChoiceField( widget=forms.RadioSelect, label='When searching and browsing,', initial='show', choices=( ( 'show', 'Show all collections except the ones selected below' ), ( 'hide', 'Hide all collections except the ones selected below' ), ), ) collections = forms.MultipleChoiceField( widget=forms.CheckboxSelectMultiple, choices=collection_choices, required=False, ) return CollectionVisibilityPreferencesForm
def duplicate(request, id, name): presentation = get_object_or_404( filter_by_access(request.user, Presentation, write=True, manage=True).filter(id=id)) target_user = None username = request.POST.get('user') if username: try: target_user = User.objects.get(username=username) except User.DoesNotExist: messages.add_message(request, messages.INFO, message="No user with username '%s' exists." % username) return HttpResponseRedirect( reverse('presentation-edit', args=(presentation.id, presentation.name))) dup = duplicate_presentation(presentation, target_user or request.user) if not target_user: return HttpResponseRedirect( reverse('presentation-edit', args=(dup.id, dup.name))) else: messages.add_message( request, messages.INFO, message="A copy of the presentation was created for user '%s'." % username) return HttpResponseRedirect( reverse('presentation-edit', args=(presentation.id, presentation.name)))
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 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( request, 'presentation_password.html', { 'form': form, 'presentation': presentation, 'next': request.GET.get('next', reverse('presentation-browse')), })
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: messages.error(request, message="An error occurred while importing the presentation.") else: messages.success(request, 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 verify_password(self, request): self.unlocked = request.user.is_superuser or ( (self.owner == request.user) or (not self.password) or (request.session.get('passwords', dict()).get(str(self.id)) == self.password)) or (filter_by_access( request.user, Presentation, manage=True).filter(id=self.id).count() > 0) return self.unlocked
def fetch_current_presentation(user): values = load_settings(user, RECENT_PRESENTATION) presentation = None if RECENT_PRESENTATION in values: presentation = filter_by_access( user, Presentation, manage=True ).filter(id=values[RECENT_PRESENTATION][0]) return presentation[0] if presentation else None
def fetch_current_presentation(user): values = load_settings(user, RECENT_PRESENTATION) presentation = None if RECENT_PRESENTATION in values: presentation = filter_by_access( user, Presentation, manage=True).filter(id=values[RECENT_PRESENTATION][0]) return presentation[0] if presentation else None
def collection_dump(user, identifier, stream=None, prefix=None): # export collection collection = filter_by_access(user, Collection).get(id=identifier) # export collection items and records collectionitems = list( CollectionItem.objects .select_related('record', 'collection') .filter(collection__id=identifier) ) ids = [collectionitem.record_id for collectionitem in collectionitems] records = list(Record.filter_by_access(user, *ids).filter(owner=None)) ids = [record.id for record in records] collectionitems = [collectionitem for collectionitem in collectionitems if collectionitem.record_id in ids] # export all fieldvalues fieldvalues = FieldValue.objects.select_related('record', 'field').filter( record__id__in=ids) used_fields = set(fieldvalue.field_id for fieldvalue in fieldvalues) # export all used fields fields = list(Field.objects.filter(id__in=used_fields).distinct()) # export equivalent fields more = True while more: eq_ids = set( id for field in fields for id in field.equivalent.values_list('id', flat=True) if id not in used_fields ) more = len(eq_ids) > 0 if more: eq_fields = Field.objects.filter(id__in=eq_ids) fields.extend(eq_fields) used_fields = used_fields.union(eq_ids) # export all used standards standards = MetadataStandard.objects.filter(id__in=set( field.standard_id for field in fields if field.standard_id )) objects = [collection] objects.extend(standards) objects.extend(fields) objects.extend(collectionitem.record for collectionitem in collectionitems) objects.extend(collectionitems) objects.extend(fieldvalues) serializer = RenamingSerializer(prefix) kwargs = dict() if stream: kwargs['stream'] = stream return serializer.serialize(objects, use_natural_keys=True, **kwargs)
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( request, 'ui_management.html', { 'storage_manage': storage_manage, 'storage_write': storage_write, 'collection_write': collection_write, 'collection_manage': collection_manage, })
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 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 _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 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 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) # django.contrib.contenttypes has been changed for dj 1.8 # ContentType.objects.get(app_label=app, model=model).model_class() is retuning None return filter_by_access(user, ContentType.objects.get_for_model(Collection).model_class(), read, write, manage)
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 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): if not self.instance.id: return self.cleaned_data['system'] else: return self.instance.system class Meta: model = Storage fields = ('title', 'system', 'base', 'credential_id', 'credential_key', 'urlbase', 'deliverybase') if request.method == "POST": if request.POST.get('delete-storage'): if not request.user.is_superuser: raise HttpResponseForbidden() messages.add_message(request, messages.INFO, 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 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 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 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(request, 'storage_manage.html', { 'storages': storages, })
def collections(request, id=None): """ @api {get} /collection/:id Get Collection Information @apiName collections @apiGroup collections @apiVersion 1.0.0 @apiParam {Number} id Collection ID. @apiDescription Returns information about a Collection obtained via filter_by_access(request.user, Collection.objects.filter(id=id)) @apiSuccessExample {json} User has access to a collection {"collections": [{"description": "Personal images", "title": "Personal Images", "agreement": null, "children": [], "owner": null, "hidden": false, "id": 1, "name": "personal-images"}], "result": "ok"} @apiSuccessExample {json} Collection does not exist {"collections": [], "result": "ok"} @apiSuccess {json} collections A list of the collections the sepecific user has access to. @apiUse csrf """ 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.username if c.owner else None, hidden=c.hidden, description=c.description, agreement=c.agreement, children=list(c.children.all().values_list('id', flat=True)), ) for c in collections] }
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 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 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 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 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 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 filter_by_access(user, *ids): records = Record.objects.distinct() ids = map(int, ids) if user and user.is_superuser: return records.filter(id__in=ids) 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 id not in individual] # check records without individual ACLs if to_check: readable = filter_by_access(user, Collection) writable = filter_by_access(user, Collection, write=True) cq = Q(collectionitem__collection__in=readable, collectionitem__hidden=False) mq = Q(collectionitem__collection__in=writable, 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) return records.filter(id__in=allowed_ids)
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 overview(request): collections = filter_by_access( request.user, Collection.objects.exclude(hidden=True)) collections = apply_collection_visibility_preferences( request.user, collections) collections = collections.annotate( num_records=Count('records')) children = dict() overview_thumbs = dict() for coll in collections: c = filter_by_access(request.user, coll.children.exclude(hidden=True)) c = apply_collection_visibility_preferences( request.user, c ) children[coll.id] = c for record in Record.objects.filter( id__in=FieldValue.objects.filter( field=get_system_field(), value='overview', index_value='overview', ).values('record'), ): for coll in record.collection_set.all().values_list('id', flat=True): overview_thumbs[coll] = record return render_to_response( 'overview.html', { 'collections': [ (coll, children[coll.id], overview_thumbs.get(coll.id)) for coll in collections ] }, context_instance=RequestContext(request))
class CollectionForm(forms.ModelForm): class UserField(forms.CharField): widget = forms.TextInput(attrs={'class': 'autocomplete-user'}) def prepare_value(self, value): try: if not value or getattr(self, "_invalid_user", False): return value return User.objects.get(id=value).username except ValueError: return value except ObjectDoesNotExist: return None def to_python(self, value): try: return User.objects.get(username=value) if value else None except ObjectDoesNotExist: self._invalid_user = True raise ValidationError('User not found') children = forms.ModelMultipleChoiceField( queryset=filter_by_access( request.user, Collection).exclude(id=collection.id), widget=forms.CheckboxSelectMultiple, required=False ) owner = UserField( widget=None if request.user.is_superuser else forms.HiddenInput, required=False ) def clean_owner(self): if not request.user.is_superuser: # non-admins cannot change collection owner return collection.owner else: return self.cleaned_data['owner'] class Meta: model = Collection fields = ( 'title', 'hidden', 'owner', 'description', 'agreement', 'children', 'order' )
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 analyze_media_task(self, owner, storage_id): storage = filter_by_access(User.objects.get(id=owner), Storage.objects.filter(id=storage_id), manage=True)[0] broken, extra = analyze_media(storage, True) broken = [m.url for m in broken] attachment = get_attachment(self) with open(attachment, 'w') as report: report.write('Analyze Report for Storage %s (%d)\n\n' % (storage.name, storage.id)) report.write('Created on %s\n\n' % datetime.now()) report.write('%d MISSING FILES:\n' % len(broken)) report.write('\n'.join(sorted(broken))) report.write('\n\n%d EXTRA FILES:\n' % len(extra)) report.write('\n'.join(sorted(extra))) return { 'attachment': attachment, }
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() messages.success(request, 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 render(self, context): record = self.record.resolve(context) fieldvalues = list(record.get_fieldvalues(owner=context['request'].user, fieldset=self.fieldset.resolve(context) if self.fieldset else None)) if fieldvalues: fieldvalues[0].subitem = False for i in range(1, len(fieldvalues)): fieldvalues[i].subitem = (fieldvalues[i].field == fieldvalues[i - 1].field and fieldvalues[i].group == fieldvalues[i - 1].group and fieldvalues[i].resolved_label == fieldvalues[i - 1].resolved_label) collections = filter_by_access(context['request'].user, record.collection_set.all()) return render_to_string('data_metadata.html', dict( values=fieldvalues, record=record, collections=collections, ), context_instance=context)
def render(self, context): record = self.record.resolve(context) fieldset = self.fieldset.resolve(context) if self.fieldset else None fieldvalues = list( record.get_fieldvalues( owner=context['request'].user, fieldset=fieldset ) ) crosslinks = self.crosslinks and self.crosslinks.resolve(context) if crosslinks: crosslink_fields = get_fields_for_set('crosslinks') else: crosslink_fields = dict() markdown_fields = get_fields_for_set('markdown') for i in range(0, len(fieldvalues)): if not fieldvalues[i].value: continue field_id = fieldvalues[i].field_id if crosslinks: fieldvalues[i].crosslinked = field_id in crosslink_fields if field_id in markdown_fields: fieldvalues[i].markdown_html = markdown(fieldvalues[i].value) collections = filter_by_access( context['request'].user, record.collection_set.all()) context.update(dict( values=fieldvalues, record=record, collections=collections, )) t = context.template.engine.get_template('data_metadata.html') return t.render(context)
def fieldvalue_autocomplete(request): collection_ids = request.GET.get('collections') if collection_ids: q = Collection.objects.filter(id__in=collection_ids.split(',')) else: q = 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] values = '\n'.join(urlquote(v) for v in values) else: values = '' return HttpResponse(content=values)
def duplicate(request, id, name): presentation = get_object_or_404( filter_by_access(request.user, Presentation, write=True, manage=True). filter(id=id) ) target_user = None username = request.POST.get('user') if username: try: target_user = User.objects.get(username=username) except User.DoesNotExist: messages.add_message( request, messages.INFO, message="No user with username '%s' exists." % username ) return HttpResponseRedirect( reverse('presentation-edit', args=(presentation.id, presentation.name))) dup = duplicate_presentation(presentation, target_user or request.user) if not target_user: return HttpResponseRedirect( reverse('presentation-edit', args=(dup.id, dup.name))) else: messages.add_message( request, messages.INFO, message="A copy of the presentation was created for user '%s'." % username ) return HttpResponseRedirect( reverse('presentation-edit', args=(presentation.id, presentation.name)))
def import_files(request): available_storage = get_list_or_404(filter_by_access(request.user, Storage, write=True).order_by('title')) available_collections = get_list_or_404(filter_by_access(request.user, Collection)) writable_collection_ids = list(filter_by_access(request.user, Collection, write=True).values_list('id', flat=True)) storage_choices = choices = [make_storage_select_choice(s, request.user) for s in available_storage] class UploadFileForm(forms.Form): collection = forms.ChoiceField( choices=((c.id, '%s%s' % ('*' if c.id in writable_collection_ids else '', c.title)) for c in sorted(available_collections, key=lambda c: c.title))) storage = forms.ChoiceField(choices=storage_choices) file = forms.FileField() create_records = forms.BooleanField(required=False) replace_files = forms.BooleanField(required=False, label='Replace files of same type') multiple_files = forms.BooleanField(required=False, label='Allow multiple files of same type') personal_records = forms.BooleanField(required=False) def clean(self): cleaned_data = self.cleaned_data if any(self.errors): return cleaned_data personal = cleaned_data['personal_records'] if not personal: if not int(cleaned_data['collection']) in writable_collection_ids: self._errors['collection'] = ErrorList(["Can only add personal records to selected collection"]) del cleaned_data['collection'] return cleaned_data if request.method == 'POST': form = UploadFileForm(request.POST, request.FILES) if form.is_valid(): create_records = form.cleaned_data['create_records'] replace_files = form.cleaned_data['replace_files'] multiple_files = form.cleaned_data['multiple_files'] personal_records = form.cleaned_data['personal_records'] collection = get_object_or_404( filter_by_access(request.user, Collection.objects.filter(id=form.cleaned_data['collection']), write=True if not personal_records else None)) storage = get_object_or_404( filter_by_access(request.user, Storage.objects.filter(id=form.cleaned_data['storage'].split(',')[0]), write=True)) file = request.FILES['file'] record = None limit = storage.get_upload_limit(request.user) if limit > 0 and file.size > limit * 1024: result = "The uploaded file is too large (%d>%d)." % (file.size, limit * 1024) else: mimetype = mimetypes.guess_type(file.name)[0] or file.content_type owner = request.user if personal_records else None id = os.path.splitext(file.name)[0] # find record by identifier titlefield = standardfield('title') idfield = standardfield('identifier') # Match identifiers that are either full file name (with extension) or just base name match records = find_record_by_identifier((id, file.name,), collection, owner=owner, ignore_suffix=multiple_files) result = "File skipped." if len(records) == 1: # Matching record found record = records[0] media = record.media_set.filter(storage=storage, mimetype=mimetype) media_same_id = media.filter(name=id) if len(media) == 0 or (len(media_same_id) == 0 and multiple_files): # No media yet media = Media.objects.create(record=record, name=id, storage=storage, mimetype=mimetype) media.save_file(file.name, file) result = "File added (Identifier '%s')." % id elif len(media_same_id) > 0 and multiple_files: # Replace existing media with same name and mimetype media = media_same_id[0] media.delete_file() media.save_file(file.name, file) result = "File replaced (Identifier '%s')." % id elif replace_files: # Replace existing media with same mimetype media = media[0] media.delete_file() media.save_file(file.name, file) result = "File replaced (Identifier '%s')." % id else: result = "File skipped, media files already attached." elif len(records) == 0: # No matching record found if create_records: # Create a record record = Record.objects.create(name=id, owner=owner) CollectionItem.objects.create(collection=collection, record=record) FieldValue.objects.create(record=record, field=idfield, value=id, order=0) FieldValue.objects.create(record=record, field=titlefield, value=id, order=1) media = Media.objects.create(record=record, name=id, storage=storage, mimetype=mimetype) media.save_file(file.name, file) result = "File added to new record (Identifier '%s')." % id else: result = "File skipped, no matching record found (Identifier '%s')." % id else: result = "File skipped, multiple matching records found (Identifier '%s')." % id # Multiple matching records found pass if request.POST.get('swfupload') == 'true': html = render_to_string('storage_import_file_response.html', {'result': result, 'record': record, }, context_instance=RequestContext(request) ) return HttpResponse(content=json.dumps(dict(status='ok', html=html)), content_type='application/json') messages.info(request, message=result) next = request.GET.get('next', request.get_full_path()) return HttpResponseRedirect(next) else: # invalid form submission if request.POST.get('swfupload') == 'true': html = render_to_string('storage_import_file_response.html', {'result': form.errors}, context_instance=RequestContext(request) ) return HttpResponse(content=json.dumps(dict(status='ok', html=html)), content_type='application/json') else: form = UploadFileForm() return render_to_response('storage_import_files.html', {'upload_form': form, }, context_instance=RequestContext(request))
def get_by_id_for_request(id, request): p = (filter_by_access(request.user, Presentation) .filter(Presentation.published_q(request.user), id=id)) return p[0] if p and p[0].verify_password(request) else None
def _supported_media(obj, user, supported_mimetypes=SUPPORTED_MIMETYPES): return obj.media_set.filter( storage__in=filter_by_access(user, Storage), mimetype__in=supported_mimetypes, )
def browse(request, manage=False): if manage and not request.user.is_authenticated(): raise Http404() if request.user.is_authenticated() and not request.GET.items(): # retrieve past settings qs = load_settings( request.user, filter='presentation_browse_querystring') if 'presentation_browse_querystring' in qs: # Don't restore the "untagged only" setting, as it confuses # a lot of users args = qs['presentation_browse_querystring'][0] args = '&'.join( p for p in args.split('&') if not p.startswith('ut=') ) return HttpResponseRedirect( '%s?%s' % ( reverse('presentation-manage' if manage else 'presentation-browse'), args, ) ) presenter = request.GET.get('presenter') tags = filter(None, request.GET.getlist('t')) sortby = request.GET.get('sortby') if sortby not in ('title', 'created', 'modified'): sortby = 'title' untagged = 1 if request.GET.get('ut') else 0 if untagged: tags = [] remove_tag = request.GET.get('rt') if remove_tag and remove_tag in tags: tags.remove(remove_tag) keywords = request.GET.get('kw', '') get = request.GET.copy() get.setlist('t', tags) if 'rt' in get: del get['rt'] if untagged: get['ut'] = '1' elif 'ut' in get: del get['ut'] if untagged and request.user.is_authenticated(): qs = TaggedItem.objects.filter( content_type=OwnedWrapper.t(OwnedWrapper) ).values('object_id').distinct() qs = OwnedWrapper.objects.filter( user=request.user, content_type=OwnedWrapper.t(Presentation), id__in=qs ).values('object_id') q = ~Q(id__in=qs) elif tags: 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 = Q(*(Q(id__in=x) for x in ids)) else: q = Q() if presenter: presenter = User.objects.get(username=presenter) qp = Q(owner=presenter) else: qp = Q() if keywords: qk = Q(*(Q(title__icontains=kw) | Q(description__icontains=kw) | Q(owner__last_name__icontains=kw) | Q(owner__first_name__icontains=kw) | Q(owner__username__icontains=kw) for kw in keywords.split())) else: qk = Q() if manage: qv = Q() presentations = filter_by_access( request.user, Presentation, write=True, manage=True) else: qv = Presentation.published_q() presentations = filter_by_access(request.user, Presentation) presentations = presentations.select_related('owner').filter(q, qp, qk, qv) presentations = presentations.order_by( '-' + sortby if sortby != 'title' else sortby) if request.method == "POST": if manage and ( request.POST.get('hide') or request.POST.get('unhide') ) and request.user.has_perm('presentation.publish_presentations'): hide = request.POST.get('hide') or False ids = map(int, request.POST.getlist('h')) for presentation in Presentation.objects.filter( owner=request.user, id__in=ids): presentation.hidden = hide presentation.save() if manage and request.POST.get('delete'): ids = map(int, request.POST.getlist('h')) Presentation.objects.filter( owner=request.user, id__in=ids).delete() get['kw'] = request.POST.get('kw') if get['kw'] != request.POST.get('okw') and 'page' in get: # user entered keywords, reset page counter del get['page'] if request.POST.get('update_tags'): ids = map(int, request.POST.getlist('h')) update_actionbar_tags(request, *presentations.filter(id__in=ids)) # check for clicks on "add selected items" buttons for button in filter( lambda k: k.startswith('add-selected-items-'), request.POST.keys()): id = int(button[len('add-selected-items-'):]) presentation = get_object_or_404( filter_by_access( request.user, Presentation, write=True, manage=True) .filter(id=id) ) add_selected_items(request, presentation) return HttpResponseRedirect( reverse( 'presentation-edit', args=(presentation.id, presentation.name) ) ) return HttpResponseRedirect(request.path + '?' + get.urlencode()) active_tags = tags def col(model, field): qn = connection.ops.quote_name return '%s.%s' % ( qn(model._meta.db_table), qn(model._meta.get_field(field).column) ) if presentations: q = OwnedWrapper.objects.extra( tables=(Presentation._meta.db_table,), where=( '%s=%s' % ( col(OwnedWrapper, 'object_id'), col(Presentation, 'id') ), '%s=%s' % ( col(OwnedWrapper, 'user'), col(Presentation, 'owner') ) ) ).filter( object_id__in=presentations.values('id'), content_type=OwnedWrapper.t(Presentation) ) tags = Tag.objects.usage_for_queryset(q, counts=True) if not manage: for p in presentations: p.verify_password(request) else: tags = () if presentations and request.user.is_authenticated(): usertags = Tag.objects.usage_for_queryset( OwnedWrapper.objects.filter( user=request.user, object_id__in=presentations.values('id'), content_type=OwnedWrapper.t(Presentation) ), counts=True ) else: usertags = () presenters = User.objects.filter(presentation__in=presentations) \ .annotate(presentations=Count('presentation')) \ .order_by('last_name', 'first_name') if request.user.is_authenticated() and presentations: # save current settings querystring = request.GET.urlencode() store_settings( request.user, 'presentation_browse_querystring', querystring) return render_to_response( 'presentation_browse.html', { 'manage': manage, 'tags': tags if len(tags) > 0 else None, 'untagged': untagged, 'usertags': usertags if len(usertags) > 0 else None, 'active_tags': active_tags, 'active_presenter': presenter, 'presentations': presentations, 'presenters': presenters if len(presenters) > 1 else None, 'keywords': keywords, 'sortby': sortby, }, context_instance=RequestContext(request) )
def browse(request, manage=False): if manage and not request.user.is_authenticated(): raise Http404() if request.user.is_authenticated() and not list(request.GET.items()) and \ not getattr(settings, 'FORGET_PRESENTATION_BROWSE_FILTER', False): # retrieve past settings qs = load_settings( request.user, filter='presentation_browse_querystring') if 'presentation_browse_querystring' in qs: # Don't restore the "untagged only" setting, as it confuses # a lot of users args = qs['presentation_browse_querystring'][0] args = '&'.join( p for p in args.split('&') if not p.startswith('ut=') ) return HttpResponseRedirect( '%s?%s' % ( reverse('presentation-manage' if manage else 'presentation-browse'), args, ) ) presenter = request.GET.get('presenter') tags = [_f for _f in request.GET.getlist('t') if _f] sortby = request.GET.get('sortby') if sortby not in ('title', 'created', 'modified'): sortby = 'title' untagged = 1 if request.GET.get('ut') else 0 if untagged: tags = [] remove_tag = request.GET.get('rt') if remove_tag and remove_tag in tags: tags.remove(remove_tag) keywords = request.GET.get('kw', '') get = request.GET.copy() get.setlist('t', tags) if 'rt' in get: del get['rt'] if untagged: get['ut'] = '1' elif 'ut' in get: del get['ut'] if untagged and request.user.is_authenticated(): qs = TaggedItem.objects.filter( content_type=OwnedWrapper.t(OwnedWrapper) ).values('object_id').distinct() qs = OwnedWrapper.objects.filter( user=request.user, content_type=OwnedWrapper.t(Presentation), id__in=qs ).values('object_id') q = ~Q(id__in=qs) elif tags: 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 = Q(*(Q(id__in=x) for x in ids)) else: q = Q() if presenter: presenter = User.objects.get(username=presenter) qp = Q(owner=presenter) else: qp = Q() if keywords: qk = Q(*(Q(title__icontains=kw) | Q(description__icontains=kw) | Q(owner__last_name__icontains=kw) | Q(owner__first_name__icontains=kw) | Q(owner__username__icontains=kw) for kw in keywords.split())) else: qk = Q() if manage: qv = Q() presentations = filter_by_access( request.user, Presentation, write=True, manage=True) else: qv = Presentation.published_q() presentations = filter_by_access(request.user, Presentation) presentations = presentations.select_related('owner').filter(q, qp, qk, qv) presentations = presentations.order_by( '-' + sortby if sortby != 'title' else sortby) if request.method == "POST": if manage and ( request.POST.get('hide') or request.POST.get('unhide') ) and request.user.has_perm('presentation.publish_presentations'): hide = request.POST.get('hide') or False ids = list(map(int, request.POST.getlist('h'))) for presentation in Presentation.objects.filter( owner=request.user, id__in=ids): presentation.hidden = hide presentation.save() if manage and request.POST.get('delete'): ids = list(map(int, request.POST.getlist('h'))) Presentation.objects.filter( owner=request.user, id__in=ids).delete() get['kw'] = request.POST.get('kw') if get['kw'] != request.POST.get('okw') and 'page' in get: # user entered keywords, reset page counter del get['page'] if request.POST.get('update_tags'): ids = list(map(int, request.POST.getlist('h'))) update_actionbar_tags(request, *presentations.filter(id__in=ids)) # check for clicks on "add selected items" buttons for button in [k for k in list(request.POST.keys()) if k.startswith('add-selected-items-')]: id = int(button[len('add-selected-items-'):]) presentation = get_object_or_404( filter_by_access( request.user, Presentation, write=True, manage=True) .filter(id=id) ) add_selected_items(request, presentation) return HttpResponseRedirect( reverse( 'presentation-edit', args=(presentation.id, presentation.name) ) ) return HttpResponseRedirect(request.path + '?' + get.urlencode()) active_tags = tags def col(model, field): qn = connection.ops.quote_name return '%s.%s' % ( qn(model._meta.db_table), qn(model._meta.get_field(field).column) ) if presentations: q = OwnedWrapper.objects.extra( tables=(Presentation._meta.db_table,), where=( '%s=%s' % ( col(OwnedWrapper, 'object_id'), col(Presentation, 'id') ), '%s=%s' % ( col(OwnedWrapper, 'user'), col(Presentation, 'owner') ) ) ).filter( object_id__in=presentations.values('id'), content_type=OwnedWrapper.t(Presentation) ) tags = Tag.objects.usage_for_queryset(q, counts=True) if not manage: for p in presentations: p.verify_password(request) else: tags = () if presentations and request.user.is_authenticated(): usertags = Tag.objects.usage_for_queryset( OwnedWrapper.objects.filter( user=request.user, object_id__in=presentations.values('id'), content_type=OwnedWrapper.t(Presentation) ), counts=True ) else: usertags = () presenters = User.objects.filter(presentation__in=presentations) \ .annotate(presentations=Count('presentation')) \ .order_by('last_name', 'first_name') if request.user.is_authenticated() and presentations: # save current settings querystring = request.GET.urlencode() store_settings( request.user, 'presentation_browse_querystring', querystring) if presentations: paginator = Paginator(presentations, 50) page = request.GET.get('page') try: presentations = paginator.page(page) except PageNotAnInteger: presentations = paginator.page(1) except EmptyPage: presentations = paginator.page(paginator.num_pages) return render( request, 'presentation_browse.html', { 'manage': manage, 'tags': tags if len(tags) > 0 else None, 'untagged': untagged, 'usertags': usertags if len(usertags) > 0 else None, 'active_tags': active_tags, 'active_presenter': presenter, 'presentations': presentations, 'presenters': presenters if len(presenters) > 1 else None, 'keywords': keywords, 'sortby': sortby, } )