def get_metadata(request):
"""
Get metadata for the given items
"""
item_list = request.POST.getlist('items')
metadata_object = request.POST.get('obj', 'original')
metadata_view = request.POST.get('advanced', False)
workspace = request.session.get('workspace', None)
user = User.objects.get(pk=request.session['_auth_user_id'])
default_language = get_metadata_default_language(user, workspace)
if metadata_view == 'true':
metadata_view = True
else:
metadata_view = False
try:
item_media_types = set(Item.objects.filter(pk__in=item_list).values_list('type__name', flat=True))
if metadata_view:
form_list = _advanced_metadata_view(item_list, workspace, default_language, metadata_object, item_media_types)
else:
form_list = _simple_metadata_view(item_list, workspace, default_language, metadata_object, item_media_types)
form_dict = {'rows': form_list}
except Exception, ex:
logger.exception(ex)
form_dict = {'rows': []}
def _read_xmp_features(self, features):
xpath = re.compile(r'(?P<prefix>\w+):(?P<property>\w+)(?P<array_index>\[\d+\]){,1}')
ctype = ContentType.objects.get_for_model(self.item)
ctype_component = ContentType.objects.get_for_model(self.component)
user = self.item.uploaded_by()
metadata_default_language = get_metadata_default_language(user)
metadata_dict = {}
metadata_list = []
delete_list = []
log.debug('READ XMP FEATURES')
if not isinstance(features, dict):
item.state = 1
item.save()
return [], []
for feature in features.keys():
try:
namespace_obj = XMPNamespace.objects.get(uri=feature)
except Exception, e:
log.error('####### Error: unknown namespace %s: %s' % (feature, str(e)))
continue
metadata_dict[namespace_obj] = {}
namespace_properties = MetadataProperty.objects.filter(namespace=namespace_obj)
for property_values in features[feature]:
property_xpath = property_values[0]
property_value = property_values[1]
property_options = property_values[2]
xpath_splitted = xpath.findall(property_xpath)
metadata_property = xpath_splitted[0][1].strip()
metadata_index = xpath_splitted[0][2].strip()
found_property = namespace_properties.filter(field_name__iexact=metadata_property)
if found_property.count() > 0 and len(property_value.strip()) > 0:
if found_property[0].is_array == 'not_array':
delete_list.append(found_property[0])
if property_options['IS_QUALIFIER'] and xpath_splitted[-1][1] == 'lang':
#log.debug('############# setting throw away IS_QUALIFIER option')
find_xpath = property_xpath.replace('/?xml:lang', '')
if metadata_dict[namespace_obj].has_key(find_xpath):
if property_value == 'x-default':
property_value = metadata_default_language
metadata_dict[namespace_obj][find_xpath].language = property_value
else:
log.debug('metadata property not found: ' + find_xpath)
pass
#log.debug('###@@@@ %s: (%s)' % (find_xpath, property_value))
else:
if found_property[0].is_variant:
x = MetadataValue(schema=found_property[0], object_id=self.component.pk, content_type=ctype_component, value=property_value, xpath=property_xpath)
else:
x = MetadataValue(schema=found_property[0], object_id=self.item.pk, content_type=ctype, value=property_value, xpath=property_xpath)
metadata_dict[namespace_obj][property_xpath] = x
metadata_list.append(x)
def _cb_xmp_ok(self, features):
try:
ctype_component = ContentType.objects.get_for_model(self.component)
ctype = ContentType.objects.get_for_model(self.item)
xpath = re.compile(r'(?P<prefix>\w+):(?P<property>\w+)(?P<array_index>\[\d+\]){,1}')
user = self.item.uploaded_by()
metadata_default_language = get_metadata_default_language(user)
except Exception, e:
log.error('Error in %s: %s %s' % (self.__class__.__name__, type(e), str(e)))
return
def _save_uploaded_component(request, res_id, file_name, variant, item, user, workspace):
"""
Create component for the given item and generate mediadart tasks.
Used only when user uploaded an item's variant
"""
try:
logger.debug('############### _save_uploaded_component: %s' % variant.pk)
comp = item.create_variant(variant, workspace)
if variant.auto_generated:
comp.imported = True
logger.debug('comp._id %s'%comp._id)
logger.debug('res_id %s'%res_id)
comp.file_name = file_name
comp._id = res_id
mimetypes.add_type('video/flv','.flv')
mimetypes.add_type('video/ts','.ts')
mimetypes.add_type('video/mpeg4','.m4v')
mimetypes.add_type('video/dv','.dv')
mimetypes.add_type('doc/pdf','.pdf')
mimetypes.add_type('image/nikon', '.nef')
mimetypes.add_type('image/canon', '.cr2')
mimetypes.add_type('image/digitalnegative', '.dng')
mime_type = mimetypes.guess_type(file_name)[0]
ext = mime_type.split('/')[1]
comp.format = ext
comp.save()
default_language = get_metadata_default_language(user)
for key in request.POST.keys():
if key.startswith('metadata'):
value = request.POST[key]
metadata_id = key.split('_')[-1]
descriptor = MetadataDescriptor.objects.get(pk = metadata_id)
MetadataValue.objects.save_descriptor_values(descriptor, item, value, workspace, 'original', default_language)
metadataschema_mimetype = MetadataProperty.objects.get(namespace__prefix='dc',field_name='format')
orig=MetadataValue.objects.create(schema=metadataschema_mimetype, content_object=comp, value=mime_type)
transaction.commit()
generate_tasks(comp, workspace)
#- if not variant.auto_generated:
#- for ws in item.workspaces.all():
#- EventRegistration.objects.notify('upload', workspace, **{'items':[item]})
except Exception, ex:
print traceback.print_exc(ex)
transaction.rollback()
raise
def _save_uploaded_component(request, res_id, file_name, variant, item, user, workspace):
"""
Create component for the given item and generate mediadart tasks.
Used only when user uploaded an item's variant
"""
try:
logger.debug('############### _save_uploaded_component: %s' % variant.pk)
comp = item.create_variant(variant, workspace)
if variant.auto_generated:
comp.imported = True
logger.debug('comp._id %s'%comp._id)
logger.debug('res_id %s'%res_id)
comp.file_name = file_name
comp._id = res_id
mimetypes.add_type('video/flv','.flv')
mimetypes.add_type('video/ts','.ts')
mimetypes.add_type('video/mpeg4','.m4v')
mimetypes.add_type('video/dv','.dv')
mimetypes.add_type('doc/pdf','.pdf')
mimetypes.add_type('image/nikon', '.nef')
mimetypes.add_type('image/canon', '.cr2')
mimetypes.add_type('image/digitalnegative', '.dng')
mime_type = mimetypes.guess_type(file_name)[0]
ext = mime_type.split('/')[1]
comp.format = ext
comp.save()
default_language = get_metadata_default_language(user)
for key in request.POST.keys():
if key.startswith('metadata'):
value = request.POST[key]
metadata_id = key.split('_')[-1]
descriptor = MetadataDescriptor.objects.get(pk = metadata_id)
MetadataValue.objects.save_descriptor_values(descriptor, item, value, workspace, 'original', default_language)
metadataschema_mimetype = MetadataProperty.objects.get(namespace__prefix='dc',field_name='format')
orig=MetadataValue.objects.create(schema=metadataschema_mimetype, content_object=comp, value=mime_type)
transaction.commit()
generate_tasks(comp, workspace)
#- if not variant.auto_generated:
#- for ws in item.workspaces.all():
#- EventRegistration.objects.notify('upload', workspace, **{'items':[item]})
except Exception, ex:
print traceback.print_exc(ex)
transaction.rollback()
raise
def save_descriptors(request):
"""
Save descriptors values (method called by DAM GUI)
"""
metadata = simplejson.loads(request.POST.get('metadata'))
item_list = request.POST.getlist('items')
variant_name = request.POST.get('obj', 'original')
ctype_item = ContentType.objects.get_for_model(Item)
ctype_obj = ContentType.objects.get_for_model(Component)
workspace = request.session.get('workspace', None)
user = User.objects.get(pk=request.session['_auth_user_id'])
default_language = get_metadata_default_language(user, workspace)
items = Item.objects.filter(pk__in=item_list)
Latitude = None
Longitude = None
logger.debug('metadata %s'%metadata)
for m in metadata:
logger.debug('m %s'%m)
ids = m.split('_')
desc_id = ids[1]
if desc_id == 'license':
logger.debug('license')
license_id = metadata[m]
license = RightsValue.objects.get(pk=int(license_id))
comp = Component.objects.get(item=item, variant__name=variant_name, workspace=workspace)
comp.save_rights_value(license, workspace)
else:
descriptor = MetadataDescriptor.objects.get(pk=int(desc_id))
#logger.debug('descriptor %s'%descriptor)
if descriptor.name == 'Latitude':
Latitude = metadata[m]
elif descriptor.name == 'Longitude':
Longitude = metadata[m]
logger.debug('ids %s'%ids)
if len(ids) == 2:
try:
MetadataValue.objects.save_descriptor_values(descriptor, items, metadata[m], workspace, variant_name, default_language)
except Exception, ex:
logger.debug('Error while saving descriptor %s' % ex )
raise ex
else:
MetadataValue.objects.save_descriptor_structure_values(descriptor, ids[2], items, metadata[m], workspace, variant_name)
def _cb_xmp_ok(self, features):
try:
ctype_component = ContentType.objects.get_for_model(self.component)
ctype = ContentType.objects.get_for_model(self.item)
xpath = re.compile(
r'(?P<prefix>\w+):(?P<property>\w+)(?P<array_index>\[\d+\]){,1}'
)
user = self.item.uploaded_by()
metadata_default_language = get_metadata_default_language(user)
except Exception, e:
log.error('Error in %s: %s %s' %
(self.__class__.__name__, type(e), str(e)))
self.deferred.errback(e)
return
def _run_sync_pipes(items, original_name, variants, workspace, user):
pipes = Pipeline.objects.filter(triggers__name='sync_xmp')
if not pipes:
raise Exception('No pipelines registered for trigger event "sync_xmp"')
# update xmp:MetadataDate
try:
default_language= get_metadata_default_language(user, workspace)
metadata_schema = MetadataProperty.objects.get(field_name = 'MetadataDate')
metadataschema_id = str(metadata_schema.pk)
metadatavalue = time.strftime("%d/%m/%yT%H:%M%S",time.gmtime()) + time.strftime('%z')
my_metadata = {metadataschema_id.decode('utf-8'):[metadatavalue.decode('utf-8')]}
items_objs = Item.objects.filter(pk__in=items)
MetadataValue.objects.save_metadata_value(items_objs, my_metadata, original_name, workspace, default_language)
except Exception, err:
logger.debug('Error while changing xmp MetadataDate: ')
logger.exception(err)
def save_metadata(request):
"""
Save XMP Values for the items in item_list
"""
metadata = simplejson.loads(request.POST.get('metadata'))
item_list = request.POST.getlist('items')
variant_name = request.POST.get('obj', 'original')
workspace = request.session.get('workspace', None)
user = User.objects.get(pk=request.session['_auth_user_id'])
default_language = get_metadata_default_language(user, workspace)
items = Item.objects.filter(pk__in=item_list)
MetadataValue.objects.save_metadata_value(items, metadata, variant_name, workspace, default_language)
_save_coords(items, metadata)
return HttpResponse('OK')
def get_formatted_descriptors(self, group, user, workspace):
"""
Retrieves all the values for the descriptors for the current component
and returns them in the format required by the Metadata GUI
@param group an instance of MetadataDescriptorGroup
@param user an instance of auth.User
@param workspace an instance of workspace.DAMWorkspace
"""
from dam.metadata.models import MetadataDescriptor, MetadataProperty
from dam.preferences.views import get_metadata_default_language
descriptors = self.get_descriptors(group)
default_language = get_metadata_default_language(user, workspace)
values = []
for d, v in descriptors.iteritems():
desc = MetadataDescriptor.objects.get(pk=d)
desc_dict = {'caption': '%s' % desc.name}
desc_value = v
logger.info("desc_value %s " % desc_value)
if isinstance(v, dict):
if v.has_key(default_language):
desc_value = v.get(default_language)
else:
continue
elif isinstance(v, list):
for value in v:
if isinstance(value, dict):
if not isinstance(desc_value, dict):
desc_value = {'properties': []}
for key, v_value in value.iteritems():
p = MetadataProperty.objects.get(pk=key)
desc_value['properties'].append({
'caption': p.caption,
'value': v_value
})
desc_dict['value'] = desc_value
values.append(desc_dict)
return values
def get_formatted_descriptors(self, group, user, workspace):
"""
Retrieves all the values for the descriptors for the current component
and returns them in the format required by the Metadata GUI
@param group an instance of MetadataDescriptorGroup
@param user an instance of auth.User
@param workspace an instance of workspace.DAMWorkspace
"""
from dam.metadata.models import MetadataDescriptor, MetadataProperty
from dam.preferences.views import get_metadata_default_language
descriptors = self.get_descriptors(group)
default_language = get_metadata_default_language(user, workspace)
values = []
for d, v in descriptors.iteritems():
desc = MetadataDescriptor.objects.get(pk=d)
desc_dict = {'caption': '%s' % desc.name}
desc_value = v
logger.info("desc_value %s " %desc_value)
if isinstance(v, dict):
if v.has_key(default_language):
desc_value = v.get(default_language)
else:
continue
elif isinstance(v, list):
for value in v:
if isinstance(value, dict):
if not isinstance(desc_value, dict):
desc_value = {'properties': []}
for key, v_value in value.iteritems():
p = MetadataProperty.objects.get(pk=key)
desc_value['properties'].append({'caption': p.caption, 'value': v_value})
desc_dict['value'] = desc_value
values.append(desc_dict)
return values
def _save_metadata(self, features, ctype):
c = self.source
#log.debug('######## _save_metadata %s %s' % (c, features))
xmp_metadata_commons = {'size':[('notreDAM','FileSize')]}
xmp_metadata_audio = {'channels':[('xmpDM', 'audioChannelType')], 'sample_rate':[('xmpDM', 'audioSampleRate')], 'duration':[('notreDAM', 'Duration')]}
xmp_metadata_video = {'height':[('xmpDM', 'videoFrameSize','stDim','h')] , 'width':[('xmpDM', 'videoFrameSize','stDim','w')], 'r_frame_rate':[('xmpDM','videoFrameRate')], 'bit_rate':[('xmpDM','fileDataRate')], 'duration':[('notreDAM', 'Duration')]}
xmp_metadata_image = {'height':[('tiff', 'ImageLength')] , 'width':[('tiff', 'ImageWidth')]}
xmp_metadata_doc = {'pages': [('notreDAM', 'NPages')], 'Copyright': [('dc', 'rights')]}
xmp_metadata_image.update(xmp_metadata_commons)
xmp_metadata_audio.update(xmp_metadata_commons)
xmp_metadata_doc.update(xmp_metadata_commons)
xmp_metadata_video.update(xmp_metadata_audio)
xmp_metadata = {'image': xmp_metadata_image, 'video': xmp_metadata_video, 'audio': xmp_metadata_audio, 'doc': xmp_metadata_doc}
metadata_list = []
delete_list = []
media_type = c.media_type.name
user = self.item.uploaded_by()
metadata_default_language = get_metadata_default_language(user)
for feature in features.keys():
if features[feature]=='' or features[feature] == '0':
continue
if feature == 'file_size':
c.size = features[feature]
if feature == 'height':
c.height = features[feature]
elif feature == 'width':
c.width = features[feature]
try:
xmp_names = xmp_metadata[media_type][feature]
except KeyError:
continue
for m in xmp_names:
try:
ms = MetadataProperty.objects.get(namespace__prefix=m[0], field_name= m[1])
except:
log.debug( 'inside readfeatures, unknown metadata %s:%s ' % (m[0],m[1]))
continue
if ms.is_variant or c.variant.name == 'original':
if len(m) == 4:
property_xpath = "%s:%s[1]/%s:%s" % (m[0], m[1], m[2], m[3])
else:
property_xpath = ''
try:
if ms.type == 'lang':
x = MetadataValue(schema=ms, object_id=c.pk, content_type=ctype, value=features[feature], language=metadata_default_language, xpath=property_xpath)
else:
x = MetadataValue(schema=ms, object_id=c.pk, content_type=ctype, value=features[feature], xpath=property_xpath)
metadata_list.append(x)
delete_list.append(ms)
except:
log.debug('inside readfeatures, could not get %s' % ms)
continue
c.save()
return (metadata_list, delete_list)
def get_status(request):
"""
Returns information for the given items, including name, size, url of thumbnail and preview
Called every 10 seconds by the GUI for refreshing information on pending items
"""
try:
workspace = request.session.get('workspace')
user = request.user
items_in_progress = request.POST.getlist('items')
logger.debug('items_in_progress %s'%items_in_progress)
resp = {'items':[]}
#### Added by orlando
#process_id = request.POST.get('process_id')
# get completed targets
#completed_targets = ProcessTarget.objects.filter(process__workspace = workspace, target_id__in=items_in_progress, actions_todo=0).values_list('target_id', flat = True)
# info = {}
process_in_progress = Process.objects.filter(end_date__isnull = True)
if process_in_progress:
pending_items = ProcessTarget.objects.filter(process__in = process_in_progress, actions_todo__gt = 0)
else:
pending_items = ProcessTarget.objects.none()
resp['status_bar'] = {
'process_in_progress': process_in_progress.count(),
'pending_items': pending_items.count()
}
####
if request.POST.get('update_script_monitor'):
from dam.scripts.views import _script_monitor
processes_info = _script_monitor(workspace)
resp['scripts'] = processes_info
thumb_caption_setting = DAMComponentSetting.objects.get(name='thumbnail_caption')
thumb_caption = thumb_caption_setting.get_user_setting(user, workspace)
fullscreen_caption_setting = DAMComponentSetting.objects.get(name='fullscreen_caption')
fullscreen_caption = fullscreen_caption_setting.get_user_setting(user, workspace)
default_language = get_metadata_default_language(user, workspace)
check_deleted = request.POST.has_key('show_deleted')
for item_id in items_in_progress:
try:
item = Item.objects.get(pk = int(item_id))
#tmp = item.get_info(workspace, user)
tmp = item.get_info(workspace, thumb_caption, default_language, check_deleted = check_deleted, fullscreen_caption = fullscreen_caption)
# if item_id not in completed_targets:
# tmp['status'] = 'in_progress'
# else:
# tmp['status'] = 'completed'
resp['items'].append(tmp)
except Item.DoesNotExist:
logger.debug('process target not found for item %s'%item_id)
continue
logger.info('resp: %s' % resp)
resp = simplejson.dumps(resp)
return HttpResponse(resp)
except Exception,ex:
logger.exception(ex)
raise ex
def load_items(request, view_type=None, unlimited=False):
logger.debug('******************** load_items')
logger.debug('request POST inside* load_items %s' % request.POST )
from datetime import datetime
try:
user = request.user
workspace = request.session['workspace']
media_type = request.POST.getlist('media_type')
# save media type on session
if request.session.__contains__('media_type'):
request.session['media_type'][workspace.pk] = list(media_type)
else:
request.session['media_type']= {workspace.pk: list(media_type)}
request.session.modified = True
start = int(request.POST.get('start', 0))
limit = int(request.POST.get('limit', 30))
if limit == 0:
start = None
limit = None
items, total_count = _search_items(request, workspace, media_type, start, limit)
item_dict = []
now = time.time()
items_pks = [item.pk for item in items]
tasks_pending_obj = []
tasks_pending = []
default_language = get_metadata_default_language(user, workspace)
user_basket = Basket.get_basket(user, workspace)
basket_items = user_basket.items.all().values_list('pk', flat=True)
items_info = []
thumb_caption_setting = DAMComponentSetting.objects.get(name='thumbnail_caption')
thumb_caption = thumb_caption_setting.get_user_setting(user, workspace)
fullscreen_caption_setting = DAMComponentSetting.objects.get(name='fullscreen_caption')
fullscreen_caption = fullscreen_caption_setting.get_user_setting(user, workspace)
default_language = get_metadata_default_language(user, workspace)
check_deleted = request.POST.has_key('show_deleted')
for item in items:
tmp = item.get_info(workspace, thumb_caption, default_language, check_deleted = check_deleted, fullscreen_caption = fullscreen_caption)
if item.pk in basket_items:
tmp['item_in_basket'] = 1
else:
tmp['item_in_basket'] = 0
items_info.append(tmp)
# for item in items:
# thumb_url,thumb_ready = _get_thumb_url(item, workspace)
# logger.debug('thumb_url,thumb_ready %s, %s'%(thumb_url,thumb_ready))
#
# geotagged = 0
# inprogress = int( (not thumb_ready) or (item.pk in tasks_pending))
#
#
# if GeoInfo.objects.filter(item=item).count() > 0:
# geotagged = 1
#
# item_in_basket = 0
#
# if item.pk in basket_items:
# item_in_basket = 1
#
# states = item.stateitemassociation_set.all()
# try:
# my_caption = _get_thumb_caption(item, thumb_caption, default_language)
# except:
# # problems retrieving thumb, skip this items
# continue
## my_caption = ''
# if inprogress:
# preview_available = tasks_pending_obj.filter(component__variant__name = 'preview', component__item = item, params__contains = 'adapt_resource').count()
# else:
# preview_available = 0
# item_info = {
# "name":my_caption,
# "pk": smart_str(item.pk),
# "geotagged": geotagged,
# "inprogress": inprogress,
# 'thumb': thumb_ready,
# 'type': smart_str(item.type.name),
# 'inbasket': item_in_basket,
# 'preview_available': preview_available,
# "url":smart_str(thumb_url), "url_preview":smart_str("/redirect_to_component/%s/preview/?t=%s" % (item.pk, now))
# }
#
# if states.count():
# state_association = states[0]
#
# item_info['state'] = state_association.state.pk
#
# item_dict.append(item_info)
logger.info('items_info: %s' % items_info)
res_dict = {"items": items_info, "totalCount": str(total_count)}
resp = simplejson.dumps(res_dict)
return HttpResponse(resp)
except Exception, ex:
logger.exception(ex)
raise ex
def _read_xmp_features(self, features):
xpath = re.compile(
r'(?P<prefix>\w+):(?P<property>\w+)(?P<array_index>\[\d+\]){,1}')
ctype = ContentType.objects.get_for_model(self.item)
ctype_component = ContentType.objects.get_for_model(self.component)
user = self.item.uploaded_by()
metadata_default_language = get_metadata_default_language(user)
metadata_dict = {}
metadata_list = []
delete_list = []
log.debug('READ XMP FEATURES')
if not isinstance(features, dict):
item.state = 1
item.save()
return [], []
for feature in features.keys():
try:
namespace_obj = XMPNamespace.objects.get(uri=feature)
except Exception, e:
log.error('####### Error: unknown namespace %s: %s' %
(feature, str(e)))
continue
metadata_dict[namespace_obj] = {}
namespace_properties = MetadataProperty.objects.filter(
namespace=namespace_obj)
for property_values in features[feature]:
property_xpath = property_values[0]
property_value = property_values[1]
property_options = property_values[2]
xpath_splitted = xpath.findall(property_xpath)
metadata_property = xpath_splitted[0][1].strip()
metadata_index = xpath_splitted[0][2].strip()
found_property = namespace_properties.filter(
field_name__iexact=metadata_property)
if found_property.count() > 0 and len(
property_value.strip()) > 0:
if found_property[0].is_array == 'not_array':
delete_list.append(found_property[0])
if property_options['IS_QUALIFIER'] and xpath_splitted[-1][
1] == 'lang':
#log.debug('############# setting throw away IS_QUALIFIER option')
find_xpath = property_xpath.replace('/?xml:lang', '')
if metadata_dict[namespace_obj].has_key(find_xpath):
if property_value == 'x-default':
property_value = metadata_default_language
metadata_dict[namespace_obj][
find_xpath].language = property_value
else:
log.debug('metadata property not found: ' +
find_xpath)
pass
#log.debug('###@@@@ %s: (%s)' % (find_xpath, property_value))
else:
if found_property[0].is_variant:
x = MetadataValue(schema=found_property[0],
object_id=self.component.pk,
content_type=ctype_component,
value=property_value,
xpath=property_xpath)
else:
x = MetadataValue(schema=found_property[0],
object_id=self.item.pk,
content_type=ctype,
value=property_value,
xpath=property_xpath)
metadata_dict[namespace_obj][property_xpath] = x
metadata_list.append(x)
def _save_metadata(self, features, ctype):
c = self.source
#log.debug('######## _save_metadata %s %s' % (c, features))
xmp_metadata_commons = {'size': [('notreDAM', 'FileSize')]}
xmp_metadata_audio = {
'channels': [('xmpDM', 'audioChannelType')],
'sample_rate': [('xmpDM', 'audioSampleRate')],
'duration': [('notreDAM', 'Duration')]
}
xmp_metadata_video = {
'height': [('xmpDM', 'videoFrameSize', 'stDim', 'h')],
'width': [('xmpDM', 'videoFrameSize', 'stDim', 'w')],
'r_frame_rate': [('xmpDM', 'videoFrameRate')],
'bit_rate': [('xmpDM', 'fileDataRate')],
'duration': [('notreDAM', 'Duration')]
}
xmp_metadata_image = {
'height': [('tiff', 'ImageLength')],
'width': [('tiff', 'ImageWidth')]
}
xmp_metadata_doc = {
'pages': [('notreDAM', 'NPages')],
'Copyright': [('dc', 'rights')]
}
xmp_metadata_image.update(xmp_metadata_commons)
xmp_metadata_audio.update(xmp_metadata_commons)
xmp_metadata_doc.update(xmp_metadata_commons)
xmp_metadata_video.update(xmp_metadata_audio)
xmp_metadata = {
'image': xmp_metadata_image,
'video': xmp_metadata_video,
'audio': xmp_metadata_audio,
'doc': xmp_metadata_doc
}
metadata_list = []
delete_list = []
media_type = c.media_type.name
user = self.item.uploaded_by()
metadata_default_language = get_metadata_default_language(user)
for feature in features.keys():
if features[feature] == '' or features[feature] == '0':
continue
if feature == 'file_size':
c.size = features[feature]
if feature == 'height':
c.height = features[feature]
elif feature == 'width':
c.width = features[feature]
try:
xmp_names = xmp_metadata[media_type][feature]
except KeyError:
continue
for m in xmp_names:
try:
ms = MetadataProperty.objects.get(namespace__prefix=m[0],
field_name=m[1])
except:
log.debug('inside readfeatures, unknown metadata %s:%s ' %
(m[0], m[1]))
continue
if ms.is_variant or c.variant.name == 'original':
if len(m) == 4:
property_xpath = "%s:%s[1]/%s:%s" % (m[0], m[1], m[2],
m[3])
else:
property_xpath = ''
try:
if ms.type == 'lang':
x = MetadataValue(
schema=ms,
object_id=c.pk,
content_type=ctype,
value=features[feature],
language=metadata_default_language,
xpath=property_xpath)
else:
x = MetadataValue(schema=ms,
object_id=c.pk,
content_type=ctype,
value=features[feature],
xpath=property_xpath)
metadata_list.append(x)
delete_list.append(ms)
except:
log.debug('inside readfeatures, could not get %s' % ms)
continue
c.save()
return (metadata_list, delete_list)