def get_media_for_record(recordid, user=None, passwords={}): """ Returns all media accessible to the user either directly through collections or indirectly through presentations. A user always must have access to the storage where the media is stored. """ from rooibos.presentation.models import Presentation print str(recordid) #record_id = getattr(record, 'id', record) print 'recordid '+ str(recordid) if isinstance(recordid, Record): record_id = recordid.id else: record_id = recordid if DEBUG: print "RECORD ID: " + str(record_id) record = Record.filter_one_by_access(user, record_id) if DEBUG: print "record filtered" if not record: print "not record in storage/init/get_media" # Try to get to record through an accessible presentation - # own presentations don't count, since it's already established that owner # doesn't have access to the record. pw_q = Q( # Presentation must not have password Q(password=None) | Q(password='') | # or must know password Q(id__in=Presentation.check_passwords(passwords)) ) access_q = Q( # Must have access to presentation id__in=filter_by_access(user, Presentation), # and presentation must not be archived hidden=False ) accessible_presentations = Presentation.objects.filter( pw_q, access_q, items__record__id=record_id) # Now get all the presentation owners so we can check if any of them have access # to the record owners = User.objects.filter(id__in=accessible_presentations.values('owner')) if not any(Record.filter_one_by_access(owner, record_id) for owner in owners): if DEBUG: print "Media.objects.none() is being returned" return Media.objects.none() #print "how many media objects: "+str(Media.objects.count()) #print "data: "+str(Media.objects.all().values("record__id", "url")) print "media filter filtered" media_filter = Media.objects.filter( record__id=record_id, #storage__id__in=filter_by_access(user, Storage), ) if not media_filter: print "oh no, no media there on line 82 of storage/__init__" print str(Media.objects.all()) print "Count: " + str(Media.objects.count()) return media_filter
def find_record_by_identifier(identifiers, collection, owner=None, ignore_suffix=False, suffix_regex=r'[-_]\d+$'): idfields = standardfield_ids('identifier', equiv=True) records = Record.by_fieldvalue(idfields, identifiers) \ .filter(collection=collection, owner=owner) if not records and ignore_suffix: if not isinstance(identifiers, (list, tuple)): identifiers = [identifiers] identifiers = (re.sub(suffix_regex, '', id) for id in identifiers) records = Record.by_fieldvalue(idfields, identifiers) \ .filter(collection=collection, owner=owner) return records
def drawCard(index, item): p.saveState() p.translate(0, height / 3 * (2 - index % 3)) # retrieve record while making sure it's accessible to presentation owner record = Record.filter_one_by_access(presentation.owner, item.record.id) if record: image = get_image_for_record(record, presentation.owner, 800, 800, passwords) if image: p.drawImage(image, inch / 2, inch / 2, width=width / 2 - inch, height=height / 3 - inch, preserveAspectRatio=True) f = Frame(width / 2 + inch / 2, inch / 2, width=width / 2 - inch, height = height / 3 - inch, leftPadding=0, bottomPadding=0, rightPadding=0, topPadding=0) data = [] data.append(getParagraph('%s/%s' % (index + 1, len(items)), styles['SlideNumber'])) values = item.get_fieldvalues(owner=request.user) for value in values: v = value.value if len(value.value) < 100 else value.value[:100] + '...' data.append(getParagraph('<b>%s:</b> %s' % (value.resolved_label, v), styles['Data'])) annotation = item.annotation if annotation: data.append(getParagraph('<b>%s:</b> %s' % ('Annotation', annotation), styles['Data'])) data = filter(None, data) f.addFromList(data, p) if data: p.setFont('Helvetica', 8) p.setFillColorRGB(0, 0, 0) p.drawRightString(width - inch / 2, inch / 2, '...') p.restoreState()
def record(request, id, name): """ @api {get} /record/:id/:name Record @apiName record @apiGroup Data @apiVersion 1.0.0 @apiParam {Number} id The ID (PK) of the specified record @apiParam {String} name The name of the record (default names will be like 'r-123456789') @apiParamExample {curl} Example usage: curl -i https://mdid.domain.edu/api/record/2991/r-7388605 @apiSuccessExample {json} Result of request ~/record/2991/r-7388605 {"record": { "name": "r-7388605", "title": "2", "image": "/media/get/2991/r-7388605/", "metadata": [ {"value": "AH-CD0000201-890", "label": "ID"}, {"value": "2", "label": "Title"}, {"value": "Indiana, Robert", "label": "Creator"}, {"value": "1966-93", "label": "Creation Year"}, {"value": "Paint on aluminum.", "label": "Medium"}, {"value": "American", "label": "Culture"}, {"value": "Modern: 19th c. to present.", "label": "Period"}, {"value": "n/a", "label": "Style"}, {"value": "n/a", "label": "Country"}, {"value": "NO", "label": "Copyright Permission"} ], "thumbnail": "/media/thumb/2991/r-7388605/", "id": 2991 }, "result": "ok" } """ # @apiSampleRequest https://mdid.domain.edu/api/record/2991/r-7388605 record = Record.get_or_404(id, request.user) return dict(record=_record_as_json(record, owner=request.user))
def drawCard(index, item): p.saveState() p.translate(0, height / 3 * (2 - index % 3)) # retrieve record while making sure it's accessible to presentation owner record = Record.filter_one_by_access(presentation.owner, item.record.id) if record: image = get_image_for_record(record, presentation.owner, 800, 800, passwords) if image: p.drawImage(image, inch / 2, inch / 2, width=width / 2 - inch, height=height / 3 - inch, preserveAspectRatio=True) f = Frame(width / 2 + inch / 2, inch / 2, width=width / 2 - inch, height=height / 3 - inch, leftPadding=0, bottomPadding=0, rightPadding=0, topPadding=0) data = [] data.append(getParagraph('%s/%s' % (index + 1, len(items)), styles['SlideNumber'])) values = item.get_fieldvalues(owner=request.user) for value in values: v = value.value if len(value.value) < 100 else value.value[:100] + '...' v = remove_rels_from_a_tags(v) data.append(getParagraph('<b>%s:</b> %s' % (value.resolved_label, v), styles['Data'])) annotation = item.annotation if annotation: data.append(getParagraph('<b>%s:</b> %s' % ('Annotation', annotation), styles['Data'])) data = filter(None, data) f.addFromList(data, p) if data: p.setFont('Helvetica', 8) p.setFillColorRGB(0, 0, 0) p.drawRightString(width - inch / 2, inch / 2, '...') p.restoreState()
def delete_selected_records(request): selected = list(request.session['selected_records']) deletable_items = [] for record in Record.filter_by_access(request.user, *selected): if record.editable_by(request.user): deletable_items.append(record) if request.method == 'POST': for record in deletable_items: if record.id in selected: selected.remove(record.id) record.delete() request.session['selected_records'] = selected from rooibos.middleware import HistoryMiddleware return HttpResponseRedirect( request.GET.get( 'next', HistoryMiddleware.go_back( request, to_before=reverse('ui-delete-selected'), default=reverse('solr-selected')))) return render_to_response('ui_delete_selected.html', { 'items': deletable_items, }, context_instance=RequestContext(request))
def set_marker(request, id, name): if request.method == "POST": index = request.POST['index'] time = request.POST['time'] if index and time: record = Record.filter_one_by_access(request.user, id) can_edit = record.editable_by(request.user) markers = get_markers(record) m = dict(map(lambda v: v.split(','), markers.value.split())) if markers.value else dict() m[index] = time to_remove = [] prev_val = None for key in sorted(m.keys()): if prev_val: if prev_val >= m[key]: to_remove.append(key) else: prev_val = m[key] for key in to_remove: del m[key] markers.value = '\n'.join('%s,%s' % (v,k) for v,k in m.iteritems()) markers.save() return dict(message="Marker saved.") else: return dict(result="Error", message="Missing parameters") else: return dict(result="Error", message="Invalid method. Use POST.")
def delete_selected_records(request): selected = list(request.session['selected_records']) deletable_items = [] for record in Record.filter_by_access(request.user, *selected): if record.editable_by(request.user): deletable_items.append(record) if request.method == 'POST': for record in deletable_items: if record.id in selected: selected.remove(record.id) record.delete() request.session['selected_records'] = selected from rooibos.middleware import HistoryMiddleware return HttpResponseRedirect( request.GET.get('next', HistoryMiddleware.go_back( request, to_before=reverse('ui-delete-selected'), default=reverse('solr-selected')))) return render_to_response('ui_delete_selected.html', { 'items': deletable_items, }, context_instance=RequestContext(request))
def set_marker(request, id, name): if request.method == "POST": index = request.POST['index'] time = request.POST['time'] if index and time: record = Record.filter_one_by_access(request.user, id) can_edit = record.editable_by(request.user) markers = get_markers(record) m = dict(map(lambda v: v.split(','), markers.value.split())) if markers.value else dict() m[index] = time to_remove = [] prev_val = None for key in sorted(m.keys()): if prev_val: if prev_val >= m[key]: to_remove.append(key) else: prev_val = m[key] for key in to_remove: del m[key] markers.value = '\n'.join('%s,%s' % (v, k) for v, k in m.iteritems()) markers.save() return dict(message="Marker saved.") else: return dict(result="Error", message="Missing parameters") else: return dict(result="Error", message="Invalid method. Use POST.")
def add_selected_items(request, presentation): selected = request.session.get('selected_records', ()) records = Record.filter_by_access(request.user, *selected) c = presentation.items.count() for record in records: c += 1 presentation.items.create(record=record, order=c) request.session['selected_records'] = ()
def draw_card(index, item): p.saveState() p.translate(0, height / 3 * (2 - index % 3)) # retrieve record while making sure it's accessible # to presentation owner record = Record.filter_one_by_access(presentation.owner, item.record.id) if record: image = get_image_for_record(record, self.user, 800, 800, passwords) if image: p.drawImage(image, inch / 2, inch / 2, width=width / 2 - inch, height=height / 3 - inch, preserveAspectRatio=True) f = Frame(width / 2 + inch / 2, inch / 2, width=width / 2 - inch, height=height / 3 - inch, leftPadding=0, bottomPadding=0, rightPadding=0, topPadding=0) data = [] data.append( get_paragraph('%s/%s' % (index + 1, len(items)), styles['SlideNumber'])) values = get_metadata(item.get_fieldvalues(owner=request.user)) for value in values: v = _clean_for_render(value['value']) data.append( get_paragraph('<b>%s:</b> %s' % (value['label'], v), styles['Data'])) annotation = item.annotation if annotation: annotation = _clean_for_render(annotation) data.append( get_paragraph( '<b>%s:</b> %s' % ('Annotation', annotation), styles['Data'])) data = [_f for _f in data if _f] incomplete = False while data: f.addFromList(data, p) if data: data = data[1:] incomplete = True if incomplete: p.setFont('Helvetica', 8) p.setFillColorRGB(0, 0, 0) p.drawRightString(width - inch / 2, inch / 2, '...') p.restoreState()
def record_usage(request, id, name): record = Record.get_or_404(id, request.user) presentations = Presentation.objects.filter(items__record=record).distinct().order_by("title") return render_to_response( "presentation_record_usage.html", {"record": record, "presentations": presentations}, context_instance=RequestContext(request), )
def record_usage(request, id, name): record = Record.get_or_404(id, request.user) presentations = Presentation.objects.filter(items__record=record).distinct().order_by('title') return render_to_response('presentation_record_usage.html', {'record': record, 'presentations': presentations, }, context_instance=RequestContext(request))
def record_usage(request, id, name): record = Record.get_or_404(id, request.user) presentations = Presentation.objects.filter( items__record=record).distinct().order_by('title') return render(request, 'presentation_record_usage.html', { 'record': record, 'presentations': presentations, })
def display_value(self, value): values = value.split('|') comment = '' if len(values) > 1: comment = (' (+%d others)' % (len(values) - 1)) for v in values: record = Record.get_primary_work_record(v) if record and record.title: return record.title + comment return value
def get_media_for_record(record, user=None, passwords={}): """ Returns all media accessible to the user either directly through collections or indirectly through presentations. A user always must have access to the storage where the media is stored. """ from rooibos.presentation.models import Presentation record_id = getattr(record, 'id', record) record = Record.filter_one_by_access(user, record_id) if not record: print "Media is not a record" # Try to get to record through an accessible presentation - # own presentations don't count, since it's already established that owner # doesn't have access to the record. pw_q = Q( # Presentation must not have password Q(password=None) | Q(password='') | # or must know password Q(id__in=Presentation.check_passwords(passwords)) ) access_q = Q( # Must have access to presentation id__in=filter_by_access(user, Presentation), # and presentation must not be archived hidden=False ) accessible_presentations = Presentation.objects.filter( pw_q, access_q, items__record__id=record_id) # Now get all the presentation owners so we can check if any of them have access # to the record owners = User.objects.filter(id__in=accessible_presentations.values('owner')) if not any(Record.filter_one_by_access(owner, record_id) for owner in owners): return Media.objects.none() print record_id print filter_by_access(user, Storage) return Media.objects.filter( record__id=record_id, storage__id__in=filter_by_access(user, Storage), )
def 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 vimeoviewer(obj, request, objid=None): if obj: if not isinstance(obj, Record): return None else: try: obj = Record.get_or_404(objid, request.user) except Http404: return None return VimeoViewer(obj, request.user) \ if _get_vimeo_links(obj).count() else None
def gifviewer(obj, request, objid=None): if obj: if not isinstance(obj, Record): return None else: try: obj = Record.get_or_404(objid, request.user) except Http404: return None media = _supported_media(obj, request.user, ['image/gif']) return GifViewer(obj, request.user) if media else None
def mediaplayer(obj, request, objid=None): if obj: if not isinstance(obj, Record): return None else: try: obj = Record.get_or_404(objid, request.user) except Http404: return None media = _supported_media(obj, request.user) return MediaPlayer(obj, request.user) if any(_check_playable(request.user, m) for m in media) else None
def find_record_by_identifier(identifiers, collection, owner=None, ignore_suffix=False, suffix_regex=r'[-_]\d+$'): idfields = standardfield_ids('identifier', equiv=True) if not isinstance(identifiers, (list, tuple)): identifiers = [identifiers] else: identifiers = list(identifiers) if ignore_suffix: identifiers.extend([re.sub(suffix_regex, '', id) for id in identifiers]) records = Record.by_fieldvalue(idfields, identifiers).filter(collection=collection, owner=owner).distinct() return records
def _get_record_and_media(self, request, id, mediaid=None): record = Record.get_or_404(id, request.user) storages = filter_by_access(request.user, Storage) media = record.media_set.filter(storage__in=filter_by_access(request.user, Storage), mimetype__in=self._supported_mimetypes).order_by('bitrate') if mediaid: media = media.filter(id=mediaid) media = filter(lambda m: self._check_playable(request.user, m), media) if not media: raise Http404() return (record, media)
def pdfviewer(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 if obj.media_set.filter(mimetype='application/pdf').count() == 0: return None return PdfViewer(obj, request.user)
def pdfviewer(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 if obj.media_set.filter(mimetype="application/pdf").count() == 0: return None return PdfViewer(obj, request.user)
def selected_records(request): selected = request.session.get('selected_records', ()) if selected: records = Record.filter_by_access(request.user, *selected)[:200] else: records = None return { 'selected_records_count': len(selected), 'selected_records': records, }
def add_selected_items(request, presentation): selected = request.session.get('selected_records', ()) records = Record.filter_by_access(request.user, *selected) # records may have been returned in different order records = dict((r.id, r) for r in records) c = presentation.items.count() for rid in selected: record = records.get(rid) if record: c += 1 presentation.items.create(record=record, order=c) request.session['selected_records'] = ()
def match_up_media(storage, collection): broken, files = analyze_media(storage) # find records that have an ID matching one of the remaining files idfields = standardfield('identifier', equiv=True) results = [] for file in files: # Match identifiers that are either full file name (with extension) or just base name match filename = os.path.split(file)[1] id = os.path.splitext(filename)[0] records = Record.by_fieldvalue(idfields, (id, filename)).filter(collection=collection, owner=None) if len(records) == 1: results.append((records[0], file)) return results
def media_upload(request, recordid, record): record = Record.get_or_404(recordid, request.user) if not record.editable_by(request.user): raise Http404() if request.method == 'POST': UploadFileForm = media_upload_form(request) if not UploadFileForm: raise Http404() form = UploadFileForm(request.POST, request.FILES) if form.is_valid(): storage = Storage.objects.get( id=form.cleaned_data['storage'].split(',')[0]) file = request.FILES['file'] mimetype = mimetypes.guess_type(file.name)[0] or file.content_type limit = storage.get_upload_limit(request.user) if limit > 0 and file.size > limit * 1024: request.user.message_set.create( message="The uploaded file is too large.") return HttpResponseRedirect( request.GET.get('next', reverse('main'))) media = Media.objects.create(record=record, name=os.path.splitext(file.name)[0], storage=storage, mimetype=mimetype) media.save_file(file.name, file) if request.POST.get('swfupload') == 'true': html = render_to_string( 'storage_import_file_response.html', { 'result': 'saved', 'record': record, 'sidebar': request.GET.has_key('sidebar'), }, context_instance=RequestContext(request)) return HttpResponse(content=simplejson.dumps( dict(status='ok', html=html)), mimetype='application/json') return HttpResponseRedirect( request.GET.get('next', reverse('main'))) else: # Invalid form submission raise Http404() else: return HttpResponseNotAllowed(['POST'])
def find_record_by_identifier( identifiers, collection, owner=None, ignore_suffix=False, suffix_regex=r'[-_]\d+$'): idfields = standardfield_ids('identifier', equiv=True) if not isinstance(identifiers, (list, tuple)): identifiers = [identifiers] else: identifiers = list(identifiers) if ignore_suffix: identifiers.extend( [re.sub(suffix_regex, '', id) for id in identifiers]) records = Record.by_fieldvalue( idfields, identifiers).filter( collection=collection, owner=owner).distinct() return records
def redirect_to_video(request, id): id_fields = [standardfield('identifier')] id_fields.extend(id_fields[0].get_equivalent_fields()) records = Record.by_fieldvalue(id_fields, id).filter( collection__name='online-video-collection') if not records: raise Http404() Activity.objects.create(event='ovc-redirect', request=request, content_object=records[0], data=dict(id=id)) request.master_template = 'ovc_master.html' return viewer_shell(request, 'mediaplayer', records[0].id, template='ovc_player.html')
def metadata(request, record_id): record = Record.get_or_404(record_id, request.user) data = [ dict( label=value.resolved_label, value=value.value, order=value.order, field=value.field.full_name, ) for value in record.get_fieldvalues() ] response = dict(data=data) return render_to_json_response(response, callback=request.GET.get('callback'))
def media_upload(request, recordid, record): record = Record.get_or_404(recordid, request.user) if not record.editable_by(request.user): raise Http404() if request.method == 'POST': UploadFileForm = media_upload_form(request) if not UploadFileForm: raise Http404() form = UploadFileForm(request.POST, request.FILES) if form.is_valid(): storage = Storage.objects.get(id=form.cleaned_data['storage'].split(',')[0]) file = request.FILES['file'] mimetype = mimetypes.guess_type(file.name)[0] or file.content_type limit = storage.get_upload_limit(request.user) if limit > 0 and file.size > limit * 1024: # request.user.message_set.create(message="The uploaded file is too large.") messages.error(request, message="The uploaded file is too large.") return HttpResponseRedirect(request.GET.get('next', reverse('main'))) media = Media.objects.create(record=record, name=os.path.splitext(file.name)[0], storage=storage, mimetype=mimetype) media.save_file(file.name, file) if request.POST.get('swfupload') == 'true': html = render_to_string('storage_import_file_response.html', {'result': 'saved', 'record': record, 'sidebar': request.GET.has_key('sidebar'), }, context_instance=RequestContext(request) ) return HttpResponse(content=simplejson.dumps(dict(status='ok', html=html)), mimetype='application/json') return HttpResponseRedirect(request.GET.get('next', reverse('main'))) else: # Invalid form submission raise Http404() else: return HttpResponseNotAllowed(['POST'])
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 record_thumbnail(request, id, name): print 'record_thumbnail' filename = get_thumbnail_for_record(id, request.user, crop_to_square=request.GET.has_key('square')) if filename: Activity.objects.create(event='media-thumbnail', request=request, content_type=ContentType.objects.get_for_model(Record), object_id=id, #content_object=record, data=dict(square=int(request.GET.has_key('square')))) try: return HttpResponse(content=open(filename, 'rb').read(), mimetype='image/jpeg') except IOError: logging.error("IOError: %s" % filename) record = Record.filter_one_by_access(request.user, id) if record and record.tmp_extthumb: return HttpResponseRedirect(record.tmp_extthumb) return HttpResponseRedirect(reverse('static', args=('images/thumbnail_unavailable.png',)))
def selected_records(request): selected = request.session.get('selected_records', ()) if selected: unsorted_records = dict( (r.id, r) for r in Record.filter_by_access(request.user, *selected)[:200]) # put records back in correct order records = [] for rid in selected: if rid in unsorted_records: records.append(unsorted_records[rid]) else: records = None return { 'selected_records_count': len(selected), 'selected_records': records, }
def metadata(request, record_id): record = Record.get_or_404(record_id, request.user) data = [ dict( label=value.resolved_label, value=value.value, order=value.order, field=value.field.full_name, ) for value in record.get_fieldvalues() ] response = dict(data=data) return render_to_json_response( response, callback=request.GET.get('callback') )
def record_thumbnail(request, id, name): print 'record_thumbnail' filename = get_thumbnail_for_record(id, request.user, crop_to_square=request.GET.has_key('square')) if filename: Activity.objects.create(event='media-thumbnail', request=request, content_type=ContentType.objects.get_for_model(Record), object_id=id, #content_object=record, data=dict(square=int(request.GET.has_key('square')))) try: return HttpResponse(content=open(filename, 'rb').read(), mimetype='image/jpeg') except IOError: logging.error("IOError: %s" % filename) record = Record.filter_one_by_access(request.user, id) if record and record.tmp_extthumb: return HttpResponseRedirect(record.tmp_extthumb) print "THUMBNAIL UNAVAILABLE - NO RECORD" return HttpResponseRedirect(reverse('static', args=('images/thumbnail_unavailable.png',)))
def media_upload(request, recordid, record): record = Record.get_or_404(recordid, request.user) if not record.editable_by(request.user): raise Http404() if request.method == 'POST': upload_file_form = media_upload_form(request) if not upload_file_form: raise Http404() form = upload_file_form(request.POST, request.FILES) if form.is_valid(): storage = Storage.objects.get( id=form.cleaned_data['storage'].split(',')[0]) file = request.FILES['file'] mimetype = mimetypes.guess_type(file.name)[0] or file.content_type limit = storage.get_upload_limit(request.user) if limit > 0 and file.size > limit * 1024: messages.add_message(request, messages.INFO, message="The uploaded file is too large.") return HttpResponseRedirect( validate_next_link(request.GET.get('next'), reverse('main'))) media = Media.objects.create(record=record, name=os.path.splitext(file.name)[0], storage=storage, mimetype=mimetype) media.save_file(file.name, file) return HttpResponseRedirect( validate_next_link(request.GET.get('next'), reverse('main'))) else: # Invalid form submission raise Http404() else: return HttpResponseNotAllowed(['POST'])
def record(request, id, name): record = Record.get_or_404(id, request.user) return dict(record=_record_as_json(record, owner=request.user))
def presentation_import(pres_ids, rc): print pres_ids for pres_id in pres_ids: pres_url = 'http://mdid3.temple.edu/api/presentation/' + str(pres_id) + '/' print 'fetching %s' % pres_url theShow = requests.get(pres_url, cookies=rc) #print theShow.json() jp = simplejson.loads(theShow.content) concat_description = jp['description'] presentation = Presentation.objects.create(title=jp['title'], owner=target_user, description=concat_description) # jp['content'] contains every slide for order, slide in enumerate(jp['content']): #print order, slide rec_exists = False rec_id = None print 'using storage %s' % store.base for metadata in slide['metadata']: #print 'metadata for slide %s, %s' % (slide['name'], str(metadata)) #print metadata if metadata['label'] == 'ID': print 'metadata for slide %s, %s' % (slide['name'], str(metadata)) rec_id = metadata['value'] print '%s is an ID field' % rec_id #print metadata['value'] if Record.by_fieldvalue(fid, rec_id): rec_exists = True print '%s already exists' % rec_id break # when finished checking for ID either add existing record to pres # or create record and then add it if rec_exists: # note that record is the first record in the list that is returned byfieldvalue # which should be checked for accuracy in multiple tests if there's any chance that # there could be multiple records print 'Check the following list list of records for multiple values:' print Record.by_fieldvalue(fid, rec_id) record = Record.by_fieldvalue(fid, rec_id)[0] presentation.items.create(order=order, record=record) presentation.save() print 'adding %s to presentation at position %s' % (rec_id, order) else: print 'creating record for %s' % rec_id print 'metadata:' print slide['metadata'] #record = Record.objects.create(name=rec_id, owner=target_user) record = Record.objects.create(owner=target_user) record.save() for metadata in slide['metadata']: try: target = Field.objects.get(label=metadata['label'], standard__prefix='aae') record.fieldvalue_set.create(field=target, value=metadata['value'], label=metadata['label'], ) except Exception as e: print e try: target = Field.objects.filter(label=metadata['label']) record.fieldvalue_set.create(field=target[0], value=metadata['value'], label=metadata['label'], ) print "Ok, went with %s the first field I could find to go with!" % target[0] except Exception as e_two: print e_two print "ok, giving up!" continue continue try: title = slide['title'] except: title = 'Untitled' FieldValue.objects.create(record=record, field=standardfield('title'), order=0, value=title) col_i = CollectionItem.objects.create(collection=collection, record=record) print 'collection item created: %s' % col_i ## file biz # media_req.content contains the image media_url = mdid_base_url + slide['image'] print 'media_url: %s' % media_url media_req = requests.get(media_url, cookies=rc) mimetype = media_req.headers['content-type'] file = StringIO(media_req.content) if guess_extension(mimetype) == '.jpeg': filename = record.name + '.jpg' extension = 'JPEG' else: filename = os.path.join(record.name + guess_extension(mimetype)) extension = os.path.splitext(mimetype)[0] print 'extension %s' % extension file_path = os.path.join(store.base, filename) print 'saving media file for %s to %s' % (record.name, file_path) media = Media.objects.create(record=record, #name=os.path.splitext(file.name)[0], name=record.name, storage=store, mimetype=mimetype) media.save_file(filename, file) presentation.items.create(order=order, record=record) presentation.save()
def create_instance(self, row): return Record(created=row.Created or row.Modified or datetime.now(), name=row.Resource.rsplit('.', 1)[0])
def getImage(identifier): i = int(identifier) return ResultRecord(Record.filter_one_by_access(AnonymousUser(), i), identifier)
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 = accessible_ids(request.user, Collection, write=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') 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'] 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') idfields = standardfield('identifier', equiv=True) # Match identifiers that are either full file name (with extension) or just base name match records = Record.by_fieldvalue(idfields, (id, file.name)).filter(collection=collection, owner=owner) result = "File skipped." if len(records) == 1: # Matching record found record = records[0] media = record.media_set.filter(storage=storage, mimetype=mimetype) if len(media) == 0: # 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 replace_files: # Replace existing media 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=simplejson.dumps(dict(status='ok', html=html)), mimetype='application/json') request.user.message_set.create(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=simplejson.dumps(dict(status='ok', html=html)), mimetype='application/json') else: form = UploadFileForm() return render_to_response('storage_import_files.html', {'upload_form': form, }, context_instance=RequestContext(request))
def _get_record_and_access(self, request, id, name): record = Record.get_or_404(id, request.user) can_edit = request.user.is_authenticated() and record.editable_by(request.user) return (record, can_edit)