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 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 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 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 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 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()
