示例#1
0
def match_up_files(request):
    available_storage = get_list_or_404(filter_by_access(request.user, Storage, manage=True).order_by('title').values_list('id', 'title'))
    available_collections = get_list_or_404(filter_by_access(request.user, Collection, manage=True))

    class MatchUpForm(forms.Form):
        collection = forms.ChoiceField(choices=((c.id, c.title) for c in sorted(available_collections, key=lambda c: c.title)))
        storage = forms.ChoiceField(choices=available_storage)

    if request.method == 'POST':

        form = MatchUpForm(request.POST)
        if form.is_valid():

            collection = get_object_or_404(filter_by_access(request.user, Collection.objects.filter(id=form.cleaned_data['collection']), manage=True))
            storage = get_object_or_404(filter_by_access(request.user, Storage.objects.filter(id=form.cleaned_data['storage']), manage=True))

            job = JobInfo.objects.create(owner=request.user,
                func='storage_match_up_media', arg=simplejson.dumps(dict(
                collection=collection.id, storage=storage.id)))
            job.run()

            request.user.message_set.create(message='Match up media job has been submitted.')
            return HttpResponseRedirect("%s?highlight=%s" % (reverse('workers-jobs'), job.id))
    else:
        form = MatchUpForm(request.GET)

    return render_to_response('storage_match_up_files.html',
                              {'form': form,
                               },
                              context_instance=RequestContext(request))
示例#2
0
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))
示例#3
0
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))
示例#4
0
def match_up_files(request):
    available_storage = get_list_or_404(
        filter_by_access(request.user, Storage,
                         manage=True).order_by('title').values_list(
                             'id', 'title'))
    available_collections = get_list_or_404(
        filter_by_access(request.user, Collection, manage=True))

    class MatchUpForm(forms.Form):
        collection = forms.ChoiceField(choices=(
            (c.id, c.title)
            for c in sorted(available_collections, key=lambda c: c.title)))
        storage = forms.ChoiceField(choices=available_storage)

    if request.method == 'POST':

        form = MatchUpForm(request.POST)
        if form.is_valid():

            collection = get_object_or_404(
                filter_by_access(request.user,
                                 Collection.objects.filter(
                                     id=form.cleaned_data['collection']),
                                 manage=True))
            storage = get_object_or_404(
                filter_by_access(
                    request.user,
                    Storage.objects.filter(id=form.cleaned_data['storage']),
                    manage=True))

            matches = match_up_media(storage, collection)

            for record, filename in matches:
                id = os.path.splitext(os.path.split(filename)[1])[0]
                mimetype = mimetypes.guess_type(
                    filename)[0] or 'application/octet-stream'
                media = Media.objects.create(record=record,
                                             name=id,
                                             storage=storage,
                                             url=filename,
                                             mimetype=mimetype)

            request.user.message_set.create(
                message='%s files were matched up with existing records.' %
                len(matches))
            return HttpResponseRedirect(
                '%s?collection=%s&storage=%s' %
                (reverse('storage-match-up-files'), collection.id, storage.id))

    else:
        form = MatchUpForm(request.GET)

    return render_to_response('storage_match_up_files.html', {
        'form': form,
    },
                              context_instance=RequestContext(request))
示例#5
0
 def _get_record_and_media(self, request, id, mediaid=None):
     record = Record.get_or_404(id, request.user)
     storages = filter_by_access(request.user, Storage)
     media = record.media_set.filter(storage__in=filter_by_access(request.user, Storage),
                                     mimetype__in=self._supported_mimetypes).order_by('bitrate')
     if mediaid:
         media = media.filter(id=mediaid)
     media = filter(lambda m: self._check_playable(request.user, m), media)
     if not media:
         raise Http404()
     return (record, media)
示例#6
0
    def filter_by_access(user, *ids):
        records = Record.objects.distinct()

        ids = map(int, ids)

        if user:

            if user.is_superuser:
                return records.filter(id__in=ids)

            accessible_records = cache_get_many(
                ['record-access-%d-%d' % (user.id or 0, id) for id in ids],
                model_dependencies=[Record, Collection, AccessControl]
            )
            accessible_record_ids = map(lambda (k, v): (int(k.rsplit('-', 1)[1]), v), accessible_records.iteritems())

            allowed_ids = [k for k, v in accessible_record_ids if v == 't']
            denied_ids  = [k for k, v in accessible_record_ids if v == 'f']

            to_check = [id for id in ids if not id in allowed_ids and not id in denied_ids]

            if not to_check:
                return records.filter(id__in=allowed_ids)

        else:
            allowed_ids = []
            to_check = ids

        # check which records have individual ACLs set
        individual = _records_with_individual_acl_by_ids(to_check)
        if individual:
            allowed_ids.extend(filter_by_access(user, Record.objects.filter(id__in=individual)).values_list('id', flat=True))
            to_check = [id for id in to_check if not id in individual]
        # check records without individual ACLs
        if to_check:
            cq = Q(collectionitem__collection__in=filter_by_access(user, Collection),
                   collectionitem__hidden=False)
            mq = Q(collectionitem__collection__in=filter_by_access(user, Collection, write=True),
                   owner=None)
            oq = Q(owner=user) if user and not user.is_anonymous() else Q()
            records = records.filter(cq | mq | oq)
            checked = records.filter(id__in=to_check).values_list('id', flat=True)
            allowed_ids.extend(checked)

        if user:
            cache_update = dict(
                        ('record-access-%d-%d' % (user.id or 0, id), 't' if id in checked else 'f')
                         for id in to_check
                    )
            cache_set_many(cache_update, model_dependencies=[Record, Collection, AccessControl])

        return records.filter(id__in=allowed_ids)
示例#7
0
    def filter_by_access(user, *ids):
        records = Record.objects.distinct()

        ids = map(int, ids)

        if user:

            if user.is_superuser:
                return records.filter(id__in=ids)

            accessible_records = cache_get_many(
                ['record-access-%d-%d' % (user.id or 0, id) for id in ids],
                model_dependencies=[Record, Collection, AccessControl]
            )
            accessible_record_ids = map(lambda (k, v): (int(k.rsplit('-', 1)[1]), v), accessible_records.iteritems())

            allowed_ids = [k for k, v in accessible_record_ids if v == 't']
            denied_ids  = [k for k, v in accessible_record_ids if v == 'f']

            to_check = [id for id in ids if not id in allowed_ids and not id in denied_ids]

            if not to_check:
                return records.filter(id__in=allowed_ids)

        else:
            allowed_ids = []
            to_check = ids

        # check which records have individual ACLs set
        individual = _records_with_individual_acl_by_ids(to_check)
        if individual:
            allowed_ids.extend(filter_by_access(user, Record.objects.filter(id__in=individual)).values_list('id', flat=True))
            to_check = [id for id in to_check if not id in individual]
        # check records without individual ACLs
        if to_check:
            cq = Q(collectionitem__collection__in=filter_by_access(user, Collection),
                   collectionitem__hidden=False)
            mq = Q(collectionitem__collection__in=filter_by_access(user, Collection, write=True),
                   owner=None)
            oq = Q(owner=user) if user and not user.is_anonymous() else Q()
            records = records.filter(cq | mq | oq)
            checked = records.filter(id__in=to_check).values_list('id', flat=True)
            allowed_ids.extend(checked)

        if user:
            cache_update = dict(
                        ('record-access-%d-%d' % (user.id or 0, id), 't' if id in checked else 'f')
                         for id in to_check
                    )
            cache_set_many(cache_update, model_dependencies=[Record, Collection, AccessControl])

        return records.filter(id__in=allowed_ids)
示例#8
0
文件: views.py 项目: agajania/rooibos
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))
示例#9
0
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))
示例#10
0
def powerpoint(request):

    available_storage = get_list_or_404(filter_by_access(request.user, Storage, write=True).order_by('title').values_list('id', 'title'))
    available_collections = get_list_or_404(filter_by_access(request.user, Collection, write=True).order_by('title').values_list('id', 'title'))

    class UploadFileForm(forms.Form):
        title = forms.CharField(max_length=50)
        storage = forms.ChoiceField(choices=available_storage)
        collection = forms.ChoiceField(choices=available_collections)
        file = forms.FileField()

        def clean_file(self):
            file = self.cleaned_data['file']
            if not file.content_type in ('application/vnd.ms-powerpoint',
                                         'application/vnd.openxmlformats-officedocument.presentationml.presentation'):
                raise forms.ValidationError("The selected file does not appear to be a PowerPoint file")
            return file


    if request.method == 'POST':
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            tempdir = tempfile.mkdtemp()
            infile = form.cleaned_data['file']
            filename = os.path.join(tempdir, 'a.ppt' if infile.content_type == 'application/vnd.ms-powerpoint' else 'a.pptx')
            outfile = open(filename, "wb+")
            for chunk in infile.chunks():
                outfile.write(chunk)
            outfile.close()
            presentation = convert_ppt(request.user,
                                       form.cleaned_data['title'],
                                       Collection.objects.get(id=form.cleaned_data['collection'],
                                                              id__in=accessible_ids(request.user, Collection, write=True)),
                                       Storage.objects.get(id=form.cleaned_data['storage'],
                                                           id__in=accessible_ids(request.user, Storage, write=True)),
                                       tempdir,
                                       filename)
            shutil.rmtree(tempdir)
            if not presentation:
                request.user.message_set.create(message="An error occurred while importing the presentation.")
            else:
                request.user.message_set.create(message="Presentation created successfully.")
                return HttpResponseRedirect(reverse('presentation-edit',
                                                    kwargs=dict(id=presentation.id, name=presentation.name)))
    else:
        form = UploadFileForm()
    return render_to_response('powerpoint.html',
                              {'form': form},
                              context_instance=RequestContext(request))
示例#11
0
def match_up_files(request):
    available_storage = get_list_or_404(
        filter_by_access(request.user, Storage,
                         manage=True).order_by('title').values_list(
                             'id', 'title'))
    available_collections = get_list_or_404(
        filter_by_access(request.user, Collection, manage=True))

    class MatchUpForm(forms.Form):
        collection = forms.ChoiceField(choices=(
            (c.id, c.title)
            for c in sorted(available_collections, key=lambda c: c.title)))
        storage = forms.ChoiceField(choices=available_storage)

    if request.method == 'POST':

        form = MatchUpForm(request.POST)
        if form.is_valid():

            collection = get_object_or_404(
                filter_by_access(request.user,
                                 Collection.objects.filter(
                                     id=form.cleaned_data['collection']),
                                 manage=True))
            storage = get_object_or_404(
                filter_by_access(
                    request.user,
                    Storage.objects.filter(id=form.cleaned_data['storage']),
                    manage=True))

            job = JobInfo.objects.create(owner=request.user,
                                         func='storage_match_up_media',
                                         arg=simplejson.dumps(
                                             dict(collection=collection.id,
                                                  storage=storage.id)))
            job.run()

            request.user.message_set.create(
                message='Match up media job has been submitted.')
            return HttpResponseRedirect("%s?highlight=%s" %
                                        (reverse('workers-jobs'), job.id))
    else:
        form = MatchUpForm(request.GET)

    return render_to_response('storage_match_up_files.html', {
        'form': form,
    },
                              context_instance=RequestContext(request))
示例#12
0
    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))
示例#13
0
    def view(self, request, id, name, template="audiotextsync/audiotextsync.html"):
        next = request.GET.get("next")
        record, can_edit = self._get_record_and_access(request, id, name)
        storages = filter_by_access(request.user, Storage)

        textmedia = audiomedia = None
        for media in record.media_set.filter(storage__in=storages):
            if not audiomedia and media.mimetype == "audio/mpeg":
                audiomedia = media
            elif not textmedia and media.mimetype == "text/plain":
                textmedia = media
        if not textmedia or not audiomedia:
            raise Http404()

        transcript = textmedia.load_file().readlines()
        markers = self._get_markers(record)

        return render_to_response(
            template,
            {
                "record": record,
                "next": next,
                "transcript": transcript,
                "markers": dict(map(lambda v: v.split(","), markers.value.split())) if markers.value else dict(),
                "mp3url": audiomedia.get_absolute_url(),
                "edit": can_edit,
            },
            context_instance=RequestContext(request),
        )
示例#14
0
def find_in_db(request, collection_id=None, field_id=None, value=None):
    
    collection = collection_id and get_object_or_404(filter_by_access(request.user, Collection), id=collection_id) or None

    if field_id:
	field = get_object_or_404(Field, id=field_id)
    if request.method == "POST":
	raise NotImplementedError("Can't post to find_in_db")

    user = request.user

    record_ids = FieldValue.objects.filter(field=field, value=value, record__collection=collection).values_list('record', flat=True)
    
    records = Record.objects.filter(id__in=record_ids).values_list('tmp_extthumb', 'name', 'source')
    
    keys = ['thumb_url', 'title', 'record_url']
    dicts = []
    for value_set in records:
	dicts.append(dict(zip(keys,value_set)))
    
    related_pages = [{"url": 'solr-browse', "title": "Back to Browse"}]
    return render_to_response('searcher-results.html',
	{'results': dicts,
	'hits': len(records),		# TODO, make this use count (more efficient)
	'browse': True,
	'searcher_name': collection},
	context_instance=RequestContext(request))
示例#15
0
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))
示例#16
0
def interview(request, number):

    collection = Collection.objects.get(name='shenandoah-national-park')
    record = get_object_or_404(FieldValue,
                               record__collection=collection,
                               field__label='Identifier',
                               value=number).record

    description = FieldValue.objects.filter(
        record=record,
        field__label='Description',
    ).values_list('value', flat=True)

    storages = filter_by_access(request.user, Storage)
    media = record.media_set.filter(storage__in=storages)

    images = filter(lambda m: m.mimetype == 'image/jpeg', media)

    atsviewer = audiotextsyncviewer(record, request)

    return render_to_response(
        'snp-interview.html', {
            'record': record,
            'description': description[0] if description else None,
            'interview_number': number,
            'has_audio_transcript': atsviewer,
            'has_media': len(media) > 0,
            'images': images,
        },
        context_instance=RequestContext(request))
示例#17
0
def interview(request, number):

    collection = Collection.objects.get(name='shenandoah-national-park')
    record = get_object_or_404(FieldValue,
                               record__collection=collection,
                               field__label='Identifier',
                               value=number).record

    description = FieldValue.objects.filter(record=record,
                                            field__label='Description',
                                            ).values_list('value', flat=True)

    storages = filter_by_access(request.user, Storage)
    media = record.media_set.filter(storage__in=storages)

    images = filter(lambda m: m.mimetype == 'image/jpeg', media)

    atsviewer = audiotextsyncviewer(record, request)

    return render_to_response('snp-interview.html',
                              {'record': record,
                               'description': description[0] if description else None,
                               'interview_number': number,
                               'has_audio_transcript': atsviewer,
                               'has_media': len(media) > 0,
                               'images': images,
                               },
                              context_instance=RequestContext(request))
示例#18
0
def media(request, number):

    LABELS = {
        'application/pdf': 'View PDF',
        'image/jpeg': 'View Image',
        'text/plain': 'View Text',
        'audio/mpeg': 'Listen to Audio',
    }

    collection = Collection.objects.get(name='shenandoah-national-park')
    record = get_object_or_404(FieldValue,
                               record__collection=collection,
                               field__label='Identifier',
                               value=number).record

    storages = filter_by_access(request.user, Storage)
    media = record.media_set.filter(storage__in=storages).order_by('mimetype')
    labels = [LABELS.get(m.mimetype, 'Download file') for m in media]

    return render_to_response('snp-media.html',
                              {'record': record,
                               'interview_number': number,
                               'media': zip(media, labels),
                               },
                              context_instance=RequestContext(request))
示例#19
0
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))
示例#20
0
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)))
示例#21
0
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)
    )
示例#22
0
def media(request, number):

    LABELS = {
        'application/pdf': 'View PDF',
        'image/jpeg': 'View Image',
        'text/plain': 'View Text',
        'audio/mpeg': 'Listen to Audio',
    }

    collection = Collection.objects.get(name='shenandoah-national-park')
    record = get_object_or_404(FieldValue,
                               record__collection=collection,
                               field__label='Identifier',
                               value=number).record

    storages = filter_by_access(request.user, Storage)
    media = record.media_set.filter(storage__in=storages).order_by('mimetype')
    labels = [LABELS.get(m.mimetype, 'Download file') for m in media]

    return render_to_response('snp-media.html', {
        'record': record,
        'interview_number': number,
        'media': zip(media, labels),
    },
                              context_instance=RequestContext(request))
示例#23
0
def overview(request):

    collections = filter_by_access(request.user, Collection)
    collections = apply_collection_visibility_preferences(request.user, collections)
    collections = collections.order_by("title").annotate(num_records=Count("records"))

    return render_to_response("overview.html", {"collections": collections}, context_instance=RequestContext(request))
示例#24
0
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)))
示例#25
0
def overview(request):

    collections = filter_by_access(request.user, Collection).order_by('title').annotate(num_records=Count('records'))

    return render_to_response('overview.html',
                              {'collections': collections,},
                              context_instance=RequestContext(request))
示例#26
0
def powerpoint(request):

    available_storage = get_list_or_404(filter_by_access(request.user, Storage, write=True).order_by('title').values_list('id', 'title'))
    available_collections = get_list_or_404(filter_by_access(request.user, Collection, write=True).order_by('title').values_list('id', 'title'))

    class UploadFileForm(forms.Form):
        title = forms.CharField(max_length=50)
        storage = forms.ChoiceField(choices=available_storage)
        collection = forms.ChoiceField(choices=available_collections)
        file = forms.FileField()

        def clean_file(self):
            file = self.cleaned_data['file']
            if not file.content_type in ('application/vnd.ms-powerpoint',
                                         'application/vnd.openxmlformats-officedocument.presentationml.presentation'):
                raise forms.ValidationError("The selected file does not appear to be a PowerPoint file")
            return file


    if request.method == 'POST':
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            tempdir = tempfile.mkdtemp()
            infile = form.cleaned_data['file']
            filename = os.path.join(tempdir, 'a.ppt' if infile.content_type == 'application/vnd.ms-powerpoint' else 'a.pptx')
            outfile = open(filename, "wb+")
            for chunk in infile.chunks():
                outfile.write(chunk)
            outfile.close()
            presentation = convert_ppt(request.user,
                form.cleaned_data['title'],
                filter_by_access(request.user, Collection, write=True).get(id=form.cleaned_data['collection']),
                filter_by_access(request.user, Storage, write=True).get(id=form.cleaned_data['storage']),
                tempdir,
                filename)
            shutil.rmtree(tempdir)
            if not presentation:
                request.user.message_set.create(message="An error occurred while importing the presentation.")
            else:
                request.user.message_set.create(message="Presentation created successfully.")
                return HttpResponseRedirect(reverse('presentation-edit',
                                                    kwargs=dict(id=presentation.id, name=presentation.name)))
    else:
        form = UploadFileForm()
    return render_to_response('powerpoint.html',
                              {'form': form},
                              context_instance=RequestContext(request))
示例#27
0
def get_media_for_record(recordid, user=None, passwords={}):
    """
    Returns all media accessible to the user either directly through collections
    or indirectly through presentations.
    A user always must have access to the storage where the media is stored.
    """
    from rooibos.presentation.models import Presentation
    
    print str(recordid)
    #record_id = getattr(record, 'id', record)
    print 'recordid '+ str(recordid)
    if isinstance(recordid, Record):
        record_id = recordid.id        
    else:
        record_id = recordid
    if DEBUG:
        print "RECORD ID: " + str(record_id)
    record = Record.filter_one_by_access(user, record_id)
    if DEBUG:
        print "record filtered"

    if not record:
        print "not record in storage/init/get_media"
        # Try to get to record through an accessible presentation -
        # own presentations don't count, since it's already established that owner
        # doesn't have access to the record.
        pw_q = Q(
            # Presentation must not have password
            Q(password=None) | Q(password='') |
            # or must know password
            Q(id__in=Presentation.check_passwords(passwords))
        )
        access_q = Q(
            # Must have access to presentation
            id__in=filter_by_access(user, Presentation),
            # and presentation must not be archived
            hidden=False
        )
        accessible_presentations = Presentation.objects.filter(
            pw_q, access_q, items__record__id=record_id)
        # Now get all the presentation owners so we can check if any of them have access
        # to the record
        owners = User.objects.filter(id__in=accessible_presentations.values('owner'))
        if not any(Record.filter_one_by_access(owner, record_id) for owner in owners):
            if DEBUG:
                print "Media.objects.none() is being returned"
            return Media.objects.none()
        #print "how many media objects: "+str(Media.objects.count())
        #print "data: "+str(Media.objects.all().values("record__id", "url"))
    print "media filter filtered"
    media_filter = Media.objects.filter(
        record__id=record_id,
        #storage__id__in=filter_by_access(user, Storage),
        )
    if not media_filter:
        print "oh no, no media there on line 82 of storage/__init__"
        print str(Media.objects.all())
        print "Count: " + str(Media.objects.count())
    return media_filter
示例#28
0
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))
示例#29
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)
示例#30
0
文件: ui.py 项目: radiata1891/rooibos
 def render(self, context):
     user = self.user.resolve(context)
     values = load_settings(user, RECENT_PRESENTATION)
     presentation = None
     if values.has_key(RECENT_PRESENTATION):
         presentation = filter_by_access(user, Presentation, manage=True).filter(id=values[RECENT_PRESENTATION][0])
     context[self.var_name] = presentation[0] if presentation else None
     return ''
示例#31
0
def fetch_current_presentation(user):
    values = load_settings(user, RECENT_PRESENTATION)
    presentation = None
    if values.has_key(RECENT_PRESENTATION):
        presentation = filter_by_access(
            user, Presentation,
            manage=True).filter(id=values[RECENT_PRESENTATION][0])
    return presentation[0] if presentation else None
示例#32
0
def search_facets(request, id=None, name=None, selected=False):

    collection = get_object_or_404(filter_by_access(request.user, Collection), id=id) if id else None

    # get parameters relevant for search
    criteria = request.GET.getlist("c")
    remove = request.GET.get("rem", None)
    if remove and remove in criteria:
        criteria.remove(remove)
    keywords = request.GET.get("kw", "")

    user = request.user

    if selected:
        selected = request.session.get("selected_records", ())

    (hits, records, search_facets, orfacet, query, fields) = run_search(
        user, collection, criteria, keywords, selected=selected, remove=remove, produce_facets=True
    )

    if collection:
        url = reverse("solr-search-collection", kwargs={"id": collection.id, "name": collection.name})
    elif selected:
        url = reverse("solr-selected")
    else:
        url = reverse("solr-search")

    q = request.GET.copy()
    q = clean_record_selection_vars(q)
    q.pop("or", None)
    q.pop("rem", None)
    q.pop("action", None)
    q.pop("page", None)
    q.pop("op", None)
    q.setlist("c", criteria)
    qurl = q.urlencode()
    limit_url = "%s?%s%s" % (url, qurl, qurl and "&" or "")

    # sort facets by label
    facets = sorted(search_facets.values(), key=lambda f: f.label)

    # clean facet items
    for f in facets:
        f.clean_result(hits)

    # remove facets with only no filter options
    facets = filter(lambda f: len(f.facets) > 0, facets)

    html = render_to_string(
        "results_facets.html", {"limit_url": limit_url, "facets": facets}, context_instance=RequestContext(request)
    )

    mode, ids = get_collection_visibility_preferences(user)
    hash = calculate_hash(getattr(user, "id", 0), collection, criteria, keywords, selected, remove, mode, str(ids))

    cache.set("search_facets_html_%s" % hash, html, 300)

    return dict(html=html)
示例#33
0
def collections(request, id=None):
    if id:
        collections = filter_by_access(request.user, Collection.objects.filter(id=id))
    else:
        collections = filter_by_access(request.user, Collection)
    return {
        'collections': [
            dict(id=c.id,
                 name=c.name,
                 title=c.title,
                 owner=c.owner,
                 hidden=c.hidden,
                 description=c.description,
                 agreement=c.agreement,
                 children=list(c.children.all().values_list('id', flat=True)),
                 )
            for c in collections]
    }
示例#34
0
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))
示例#35
0
def collections(request, id=None):
    if id:
        collections = filter_by_access(request.user, Collection.objects.filter(id=id))
    else:
        collections = filter_by_access(request.user, Collection)
    return {
        'collections': [
            dict(id=c.id,
                 name=c.name,
                 title=c.title,
                 owner=c.owner,
                 hidden=c.hidden,
                 description=c.description,
                 agreement=c.agreement,
                 children=list(c.children.all().values_list('id', flat=True)),
                 )
            for c in collections]
    }
示例#36
0
 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
示例#37
0
 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
示例#38
0
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))
示例#39
0
def overview(request):

    collections = filter_by_access(request.user, Collection)
    collections = apply_collection_visibility_preferences(request.user, collections)
    collections = collections.order_by('title').annotate(num_records=Count('records'))

    return render_to_response('overview.html',
                              {'collections': collections,},
                              context_instance=RequestContext(request))
示例#40
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)
示例#41
0
文件: views.py 项目: knabar/fynbos
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))
示例#42
0
 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
示例#43
0
def get_media_for_record(record, user=None, passwords={}):
    """
    Returns all media accessible to the user either directly through collections
    or indirectly through presentations.
    A user always must have access to the storage where the media is stored.
    """
    from rooibos.presentation.models import Presentation

    record_id = getattr(record, 'id', record)
    record = Record.filter_one_by_access(user, record_id)
	
    if not record:
        print "Media is not a record"
     	# Try to get to record through an accessible presentation -
        # own presentations don't count, since it's already established that owner
        # doesn't have access to the record.
        pw_q = Q(
            # Presentation must not have password
            Q(password=None) | Q(password='') |
            # or must know password
            Q(id__in=Presentation.check_passwords(passwords))
        )
        access_q = Q(
            # Must have access to presentation
            id__in=filter_by_access(user, Presentation),
            # and presentation must not be archived
            hidden=False
        )
        accessible_presentations = Presentation.objects.filter(
            pw_q, access_q, items__record__id=record_id)
        # Now get all the presentation owners so we can check if any of them have access
        # to the record
        owners = User.objects.filter(id__in=accessible_presentations.values('owner'))
        if not any(Record.filter_one_by_access(owner, record_id) for owner in owners):
            return Media.objects.none()	
        
    print record_id
    print filter_by_access(user, Storage)

    return Media.objects.filter(
        record__id=record_id,
        storage__id__in=filter_by_access(user, Storage),
    )
示例#44
0
def media_upload_form(request):
    available_storage = filter_by_access(request.user, Storage, write=True).order_by('title').values_list('name','title')
    if not available_storage:
        return None

    class UploadFileForm(forms.Form):
        storage = forms.ChoiceField(choices=available_storage)
        file = forms.FileField()

    return UploadFileForm
示例#45
0
文件: views.py 项目: Blanko2/vic-mdid
def browse(request, id=None, name=None):

    collections = filter_by_access(request.user, Collection)
    collections = apply_collection_visibility_preferences(request.user, collections)
    collections = collections.annotate(num_records=Count('records')).filter(num_records__gt=0).order_by('title')

    if not collections:
        return render_to_response('browse.html',
                              {},
                              context_instance=RequestContext(request))

    if request.GET.has_key('c'):
        collection = get_object_or_404(collections, name=request.GET['c'])
        return HttpResponseRedirect(reverse('solr-browse-collection',
                                            kwargs={'id': collection.id, 'name': collection.name}))

    collection = id and get_object_or_404(collections, id=id) or collections[0]
    
    fields = cache.get('browse_fields_%s' % collection.id)
    if fields:
        fields = list(Field.objects.filter(id__in=fields))
    else:
        fields = list(Field.objects.filter(fieldvalue__record__collection=collection).distinct())
        cache.set('browse_fields_%s' % collection.id, [f.id for f in fields], 60)

    if not fields:
        raise Http404()

    if request.GET.has_key('f'):
        try:
            field = get_object_or_404(Field, id=request.GET['f'], id__in=(f.id for f in fields))
        except ValueError:
            # GET['f'] was text previously and external links exist that are no longer valid
            return HttpResponseRedirect(reverse('solr-browse-collection',
                                        kwargs={'id': collection.id, 'name': collection.name}))
    else:
        field = fields[0]

    values = FieldValue.objects.filter(field=field, record__collection=collection).values('value').annotate(freq=Count('value', distinct=False)).order_by('value')
    #print "solr.views 741 collection %s field %s manager %s" %(collection, field.__class__.__name__, FieldValue.objects)

    if request.GET.has_key('s'):
        start = values.filter(value__lt=request.GET['s']).count() / 50 + 1
        return HttpResponseRedirect(reverse('solr-browse-collection',
                                            kwargs={'id': collection.id, 'name': collection.name}) +
                                    "?f=%s&page=%s" % (field.id, start))

    return render_to_response('browse.html',
                              {'collections': collections,
                               'selected_collection': collection and collection or None,
                               'fields': fields,
                               'selected_field': field,
                               'values': values,},
                              context_instance=RequestContext(request))
示例#46
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))
示例#47
0
def browse(request, id=None, name=None):

    collections = filter_by_access(request.user, Collection)
    collections = apply_collection_visibility_preferences(request.user, collections)
    collections = collections.annotate(num_records=Count('records')).filter(num_records__gt=0).order_by('title')

    if not collections:
        return render_to_response('browse.html',
                              {},
                              context_instance=RequestContext(request))

    if request.GET.has_key('c'):
        collection = get_object_or_404(collections, name=request.GET['c'])
        return HttpResponseRedirect(reverse('solr-browse-collection',
                                            kwargs={'id': collection.id, 'name': collection.name}))

    collection = id and get_object_or_404(collections, id=id) or collections[0]
    
    fields = cache.get('browse_fields_%s' % collection.id)
    if fields:
        fields = list(Field.objects.filter(id__in=fields))
    else:
        fields = list(Field.objects.filter(fieldvalue__record__collection=collection).distinct())
        cache.set('browse_fields_%s' % collection.id, [f.id for f in fields], 60)

    if not fields:
        raise Http404()

    if request.GET.has_key('f'):
        try:
            field = get_object_or_404(Field, id=request.GET['f'], id__in=(f.id for f in fields))
        except ValueError:
            # GET['f'] was text previously and external links exist that are no longer valid
            return HttpResponseRedirect(reverse('solr-browse-collection',
                                        kwargs={'id': collection.id, 'name': collection.name}))
    else:
        field = fields[0]

    values = FieldValue.objects.filter(field=field, record__collection=collection).values('value').annotate(freq=Count('value', distinct=False)).order_by('value')
    print "solr.views 741 collection %s field %s manager %s" %(collection, field.__class__.__name__, FieldValue.objects)

    if request.GET.has_key('s'):
        start = values.filter(value__lt=request.GET['s']).count() / 50 + 1
        return HttpResponseRedirect(reverse('solr-browse-collection',
                                            kwargs={'id': collection.id, 'name': collection.name}) +
                                    "?f=%s&page=%s" % (field.id, start))

    return render_to_response('browse.html',
                              {'collections': collections,
                               'selected_collection': collection and collection or None,
                               'fields': fields,
                               'selected_field': field,
                               'values': values,},
                              context_instance=RequestContext(request))
示例#48
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))
示例#49
0
def match_up_files(request):
    available_storage = get_list_or_404(filter_by_access(request.user, Storage, manage=True).order_by('title').values_list('id', 'title'))
    available_collections = get_list_or_404(filter_by_access(request.user, Collection, manage=True))

    class MatchUpForm(forms.Form):
        collection = forms.ChoiceField(choices=((c.id, c.title) for c in sorted(available_collections, key=lambda c: c.title)))
        storage = forms.ChoiceField(choices=available_storage)

    if request.method == 'POST':

        form = MatchUpForm(request.POST)
        if form.is_valid():

            collection = get_object_or_404(filter_by_access(request.user, Collection.objects.filter(id=form.cleaned_data['collection']), manage=True))
            storage = get_object_or_404(filter_by_access(request.user, Storage.objects.filter(id=form.cleaned_data['storage']), manage=True))

            matches = match_up_media(storage, collection)

            for record, filename in matches:
                id = os.path.splitext(os.path.split(filename)[1])[0]
                mimetype = mimetypes.guess_type(filename)[0] or 'application/octet-stream'
                media = Media.objects.create(record=record,
                                             name=id,
                                             storage=storage,
                                             url=filename,
                                             mimetype=mimetype)

            request.user.message_set.create(message='%s files were matched up with existing records.' % len(matches))
            return HttpResponseRedirect('%s?collection=%s&storage=%s' % (
                reverse('storage-match-up-files'),
                collection.id,
                storage.id
                ))

    else:
        form = MatchUpForm(request.GET)

    return render_to_response('storage_match_up_files.html',
                              {'form': form,
                               },
                              context_instance=RequestContext(request))
示例#50
0
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
示例#51
0
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),
    )
示例#52
0
 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
示例#53
0
def manage_storage(request, storageid=None, storagename=None):

    if storageid and storagename:
        storage = get_object_or_404(filter_by_access(request.user,
                                                     Storage,
                                                     manage=True),
                                    id=storageid)
    else:
        storage = Storage(system='local')

    if not storage.id:
        system_choices = [(s, s) for s in settings.STORAGE_SYSTEMS.keys()]
    else:
        system_choices = [(storage.system, storage.system)]

    class StorageForm(forms.ModelForm):
        system = forms.CharField(widget=forms.Select(choices=system_choices))

        def clean_system(self):
            return self.cleaned_data[
                'system'] if not self.instance.id else self.instance.system

        class Meta:
            model = Storage
            exclude = ('name', 'derivative')

    if request.method == "POST":
        if request.POST.get('delete-storage'):
            if not request.user.is_superuser:
                raise HttpResponseForbidden()
            request.user.message_set.create(
                message="Storage '%s' has been deleted." % storage.title)
            storage.delete()
            return HttpResponseRedirect(reverse('storage-manage'))
        else:
            form = StorageForm(request.POST, instance=storage)
            if form.is_valid():
                form.save()
                return HttpResponseRedirect(
                    reverse('storage-manage-storage',
                            kwargs=dict(storageid=form.instance.id,
                                        storagename=form.instance.name)))
    else:
        form = StorageForm(instance=storage)

    return render_to_response('storage_edit.html', {
        'storage': storage,
        'form': form,
    },
                              context_instance=RequestContext(request))
示例#54
0
def find_in_db(request, collection_id=None, field_id=None, value=None):

    collection = collection_id and get_object_or_404(
        filter_by_access(request.user, Collection), id=collection_id) or None

    if field_id:
        field = get_object_or_404(Field, id=field_id)
    if request.method == "POST":
        raise NotImplementedError("Can't post to find_in_db")

    user = request.user

    #values = FieldValue.objects.filter(field=field, value=value, record__collection=collection)
    record_ids = FieldValue.objects.filter(
        field=field, value=value,
        record__collection=collection).values_list('record', flat=True)

    records = Record.objects.filter(
        id__in=record_ids)  #.values_list('tmp_extthumb', 'name', 'source')

    keys = ['thumb_url', 'title', 'record_url']
    dicts = []
    #iterate through the list of records and grab every attribute you need
    #for r in records:
    #get all the values and do a reverse lookup of the collection
    #manually build the dict and then pass it to the searcher-results.html
    for r in records:
        thumb_url = r.get_thumbnail_url()
        title = r.title
        #get the url for the record?
        record_location = r.get_absolute_url()
        record_list = [thumb_url, title, record_location]
        dicts.append(dict(zip(keys, record_list)))
    #for value_set in records:
    #    dicts.append(dict(zip(keys,value_set)))

    related_pages = [{"url": 'solr-browse', "title": "Back to Browse"}]
    return render_to_response(
        'searcher-results.html',
        {
            'results': dicts,
            'hits': len(records),  # TODO, make this use count (more efficient)
            'browse': True,
            'searcher_name': collection
        },
        context_instance=RequestContext(request))
示例#55
0
def fieldvalue_autocomplete(request):
    collection_ids = request.GET.get('collections')
    q = collection_ids and Collection.objects.filter(id__in=collection_ids.split(',')) or Collection
    collections = filter_by_access(request.user, q)
    if not collections:
        raise Http404()
    query = request.GET.get('q', '').lower()
    if len(query) >= 2 and len(query) <= 32:
        limit = min(int(request.GET.get('limit', '10')), 100)
        field = request.GET.get('field')
        q = field and Q(field__id=field) or Q()
        values = FieldValue.objects.filter(q, record__collection__in=collections, index_value__istartswith=query) \
            .values_list('value', flat=True).distinct()[:limit] #.order_by('value')
        #print values.query.as_sql()
        values = '\n'.join(urlquote(v) for v in values)
    else:
        values = ''
    return HttpResponse(content=values)
示例#56
0
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)
示例#57
0
def m_browse(request, manage=False):

    presenter = request.GET.get('presenter')

    tags = ["ARTH101", "ARTH102", "ARTH243"]

    qs = OwnedWrapper.objects.filter(content_type=OwnedWrapper.t(Presentation))
    # get list of matching IDs for each individual tag, since tags may be attached by different owners
    ids = [
        list(
            TaggedItem.objects.get_by_model(qs, '"%s"' % tag).values_list(
                'object_id', flat=True)) for tag in tags
    ]

    q = []
    for x in ids:
        q.append(Q(id__in=x))

    pOut = []
    presentations = filter_by_access(request.user, Presentation)

    i = 0
    for x in q:
        pOut.append(
            list(
                presentations.select_related('owner').filter(x).order_by(
                    'title')))
        i += 1

    class ACourse():
        courseName = ""
        contents = []

    def courseify(name, presentations):
        c = ACourse()
        c.courseName = name
        c.contents = presentations
        return c

    courses = map(courseify, tags, pOut)

    return render_to_response('mobilePresentationList.html',
                              {'courses': courses},
                              context_instance=RequestContext(request))