def handle_result(self, result, *args):
#log.debug('= handle_result %s' % str(result)[:128])
try:
return self.parse_stdout(result['data'], *args)
except Exception, e:
log.error('Error in %s: %s %s' % (self.__class__.__name__, type(e), str(e)))
raise
def execute(self, **params):
# get basic data (avoid creating stuff in DB)
try:
self.get_cmdline(**params)
args = splitstring(self.cmdline)
except Exception, e:
log.error('Error in %s: %s %s' % (self.__class__.__name__, type(e), str(e)))
raise
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_features(self, features, extractor_type):
"save results of basic extractions"
metadata_list, delete_list = [], []
#log.debug('ExtractBasicFeatures._save_features: %s' % features)
ctype = ContentType.objects.get_for_model(self.source)
try:
save_type(ctype, self.source)
except Exception, e:
log.error("Failed to save component format as DC:Format: %s" % (str(e)))
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 execute(self, output_variant_name, output_type, **params):
# get basic data (avoid creating stuff in DB)
try:
self.get_cmdline(output_variant_name, output_type, **params)
output_variant = Variant.objects.get(name = output_variant_name)
self.out_comp = self.item.create_variant(output_variant, self.workspace, self.out_type)
self.out_comp.source = self.source
args = splitstring(self.cmdline)
except Exception, e:
log.error('Error in %s: %s %s' % (self.__class__.__name__, type(e), str(e)))
raise
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
try:
save_type(ctype, self.component)
except Exception, e:
log.error("Failed to save component format as DC:Format: %s" % (str(e)))
return
try:
xmp_metadata_list, xmp_delete_list = self._read_xmp_features(features)
MetadataValue.objects.filter(schema__in=xmp_delete_list, object_id=self.component.pk, content_type=ctype_component).delete()
latitude = None
longitude = None
for x in xmp_metadata_list:
if x.xpath == 'exif:GPSLatitude':
latitude = x.value
elif x.xpath == 'exif:GPSLongitude':
longitude = x.value
x.save()
except Exception, e:
