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 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 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:
# 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 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 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 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 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 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 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 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 record(request, id, name):
record = Record.get_or_404(id, request.user)
return dict(record=_record_as_json(record, owner=request.user))
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)
