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 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 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 _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 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 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 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 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,
}
)
