def getImageSize(self, fieldname=None):
if fieldname is not None:
value = self.guarded_orig_image(fieldname)
if value is None:
return (0, 0)
return value.getImageSize()
value = IPrimaryFieldInfo(self.context).value
return value.getImageSize()
def add_filename_to_metadata(ob, metadata, request, response):
try:
field = IPrimaryFieldInfo(ob).field
except TypeError:
return
value = field.get(ob)
if INamedFile.providedBy(value):
filename = getattr(value, 'filename', None)
if filename is not None:
metadata.insert(0, 'filename:%s' % filename.encode('utf-8'))
def _getFile(self):
logger.info("got download request for " + self.context.absolute_url())
if utils.isJwtEnabled():
token = utils.getTokenFromHeader(self.request)
if (not token):
raise Exception('Expected JWT')
utils.decodeSecurityToken(token)
utils.checkSecurityToken(self.context,
utils.getTokenFromRequest(self.request))
if not self.fieldname:
info = IPrimaryFieldInfo(self.context, None)
if info is None:
# Ensure that we have at least a fieldname
raise NotFound(self, '', self.request)
self.fieldname = info.fieldname
file = info.value
if file is None:
raise NotFound(self, self.fieldname, self.request)
return file
def provided_data(self):
"""provided data"""
field = IPrimaryFieldInfo(self.context)
if not field.value:
return []
text = field.value.data
f = StringIO(text.decode("utf-8"))
try:
reader = csv.reader(f)
except Exception:
return []
rows = list(reader)
if not rows:
return []
keys = rows[0]
data = []
for index, row in enumerate(rows[1:]):
data.append({})
for (i, k) in enumerate(keys):
data[index][k] = row[i]
data_query = computeDataQuery(self.request)
return {
"results": filteredData(data, data_query),
"metadata": {},
}
def _getFields(self, obj, fieldNames):
# If no fieldNames have been defined as transcodable,
# then use the primary field
# TODO: check if they are actually file fields
fields = []
if IDexterityContent.providedBy(obj):
if not fieldNames:
try:
primary = IPrimaryFieldInfo(obj)
fields = [(primary.fieldname, primary.field)]
except TypeError:
log.error('No field specified and no primary field.')
else:
for f in fieldNames:
try:
fields.append((f, getattr(obj, f)))
except AttributeError:
log.error('No field %s on object %s.' % (f, obj))
else:
if not fieldNames:
fields = [obj.getPrimaryField()]
else:
fields = [obj.getField(f) for f in fieldNames]
return fields
def scale(self, fieldname=None, scale=None,
height=None, width=None, **parameters):
if not IPersistentCoverTile.providedBy(self.context):
base_scales = queryMultiAdapter((self.context, self.request),
name='images',
default=None)
if base_scales:
try:
scale = base_scales.scale(fieldname,
scale,
height,
width,
**parameters)
except AttributeError:
scale = None
return scale
else:
return None
if fieldname is None:
fieldname = IPrimaryFieldInfo(self.context).fieldname
if scale is not None:
available = self.getAvailableSizes(fieldname)
if not scale in available:
return None
width, height = available[scale]
storage = AnnotationStorage(self.context, self.modified)
info = storage.scale(factory=self.create,
fieldname=fieldname,
height=height,
width=width,
**parameters)
if info is not None:
info['fieldname'] = fieldname
scale_view = ImageScale(self.context, self.request, **info)
return scale_view.__of__(self.context)
def __init__(self, context):
self.context = context
info = IPrimaryFieldInfo(context, None)
if info is None or info.value is None:
self._file = None
else:
self._file = info.value
def __init__(self, context, feed):
super(DexterityItem, self).__init__(context, feed)
self.dexterity = IDexterityContent.providedBy(context)
try:
self.primary = IPrimaryFieldInfo(self.context, None)
except TypeError:
self.primary = None
def scale(self,
fieldname=None,
scale=None,
height=None,
width=None,
direction='thumbnail',
**parameters):
# import pdb
# pdb.set_trace()
if fieldname is None:
fieldname = IPrimaryFieldInfo(self.context).fieldname
if scale is not None:
available = self.getAvailableSizes(fieldname)
if not scale in available:
return None
width, height = available[scale]
if self.request is not None:
alsoProvides(self.request, IDisableCSRFProtection)
storage = AnnotationStorage(self.context, self.modified)
info = storage.scale(factory=self.create,
fieldname=fieldname,
height=height,
width=width,
direction=direction,
**parameters)
if info is not None:
info['fieldname'] = fieldname
scale_view = ImageScale(self.context, self.request, **info)
return scale_view.__of__(self.context)
def SearchableText_file(obj):
try:
primary_field = IPrimaryFieldInfo(obj)
except TypeError:
logger.warn(u'Lookup of PrimaryField failed for %s '
u'If renaming or importing please reindex!' %
obj.absolute_url())
return
if primary_field.value is None:
return SearchableText(obj)
mimetype = primary_field.value.contentType
transforms = getToolByName(obj, 'portal_transforms')
if transforms._findPath(mimetype, 'text/plain') is None:
# check if there is a valid transform available first
return SearchableText(obj)
value = str(primary_field.value.data)
filename = primary_field.value.filename
try:
transformed_value = transforms.convertTo('text/plain',
value,
mimetype=mimetype,
filename=filename)
if not transformed_value:
return SearchableText(obj)
return _unicode_save_string_concat(SearchableText(obj),
transformed_value.getData())
except (ConflictError, KeyboardInterrupt):
raise
except Exception, msg:
logger.exception('exception while trying to convert '
'blob contents to "text/plain" for %r. Error: %s' %
(obj, str(msg)))
return SearchableText(obj)
def getIcon_file(obj):
"""icon of the given mimetype,
parts of this this code are borrowed from atct.
"""
mtr = getToolByName(obj, 'mimetypes_registry', None)
if mtr is None:
return None
try:
primary_field_info = IPrimaryFieldInfo(obj, None)
except TypeError:
logger.warn(u'Lookup of PrimaryField failed for %s '
u'If renaming or importing please reindex!' %
obj.absolute_url())
return
if not primary_field_info.value:
# There is no file so we should show a generic icon
# TODO : find a better icon for generic
return 'png.png'
# return None
contenttype = None
if hasattr(primary_field_info.value, "contentType"):
contenttype = primary_field_info.value.contentType
if not contenttype:
contenttype = FALLBACK_CONTENTTYPE
mimetypeitem = None
try:
mimetypeitem = mtr.lookup(contenttype)
except Exception, msg:
logger.warn('mimetype lookup failed for %s. Error: %s' %
(obj.absolute_url(), str(msg)))
def __call__(self):
e = {}
ob = self.context
title = ob.Title()
if type(title) != unicode:
title.decode('utf-8')
e[u'title'] = title
e[u'author_name'] = self._getAuthorName()
try:
info = IPrimaryFieldInfo(ob)
except TypeError:
info = None
if info is None:
e[u'type'] = 'link'
else:
field = info.field
if IRichText.providedBy(field):
e[u'type'] = 'rich'
e[u'html'] = info.value
elif INamedImageField.providedBy(field):
e[u'type'] = 'photo'
e[u'url'] = ob.absolute_url()
image = field.get(ob)
e[u'width'], e['height'] = image.getImageSize()
else:
e[u'type'] = 'link'
return e
def SearchableText_file(obj):
primary_field = IPrimaryFieldInfo(obj)
if primary_field.value is None:
return SearchableText(obj)
mimetype = primary_field.value.contentType
transforms = getToolByName(obj, 'portal_transforms')
if transforms._findPath(mimetype, 'text/plain') is None:
# check if there is a valid transform available first
return SearchableText(obj)
value = str(primary_field.value.data)
filename = primary_field.value.filename
try:
transformed_value = transforms.convertTo('text/plain',
value,
mimetype=mimetype,
filename=filename)
if not transformed_value:
return SearchableText(obj)
return _unicode_save_string_concat(SearchableText(obj),
transformed_value.getData())
except (ConflictError, KeyboardInterrupt):
raise
except:
logger.exception(
'exception while trying to convert '
'blob contents to "text/plain" for %r', obj)
return SearchableText(obj)
def blob_data(self):
pfi = IPrimaryFieldInfo(self.context, None)
if pfi is not None:
named_blob = pfi.field.get(self.context)
if named_blob is not None:
return named_blob.data
return None
def __call__(self):
version_id = self.request.get('version_id', None)
if not version_id:
raise ValueError(u'Missing parameter on the request: version_id')
field_id = self.request.get('field_id',
IPrimaryFieldInfo(self.context).fieldname)
filename = self.request.get('filename')
do_not_stream = self.request.get('do_not_stream')
repository = getToolByName(self.context, 'portal_repository')
old_obj = repository.retrieve(self.context, version_id).object
# Will only work if the file is stored as an attribute with the same
# name of the field.
file_ = getattr(old_obj, field_id, None)
if file_ is None:
raise NotFound(self, filename, self.request)
set_headers(file_, self.request.response, filename=filename)
if do_not_stream:
return file_.data
return stream_data(file_)
def __init__(self, context):
super(DexterityItem, self).__init__(context)
try:
self.primary = IPrimaryFieldInfo(self.context, None)
except TypeError:
# plone/dexterity/primary.py raises TypeError("Could not adapt")
# if there is not primary field
self.primary = None
def filename(obj):
try:
info = IPrimaryFieldInfo(obj.getObject())
except TypeError:
return None
if info.value is None:
return None
return info.value.filename
def filesize(obj):
try:
info = IPrimaryFieldInfo(obj.getObject())
except TypeError:
return 0
if info.value is None:
return 0
return info.value.size
def create_or_modify_content(self, tus_upload):
metadata = tus_upload.metadata()
filename = metadata.get("filename", "")
content_type = metadata.get("content-type", "application/octet-stream")
mode = metadata.get("mode", "create")
fieldname = metadata.get("fieldname")
if mode == "create":
type_ = metadata.get("@type")
if type_ is None:
ctr = getToolByName(self.context, "content_type_registry")
type_ = ctr.findTypeName(filename.lower(), content_type, "") or "File"
obj = create(self.context, type_)
else:
obj = self.context
if not fieldname:
info = IPrimaryFieldInfo(obj, None)
if info is not None:
fieldname = info.fieldname
elif base_hasattr(obj, "getPrimaryField"):
field = obj.getPrimaryField()
fieldname = field.getName()
if not fieldname:
return self.error("Bad Request", "Fieldname required", 400)
# Acquisition wrap temporarily for deserialization
temporarily_wrapped = False
if IAcquirer.providedBy(obj) and not safe_hasattr(obj, "aq_base"):
obj = obj.__of__(self.context)
temporarily_wrapped = True
# Update field with file data
deserializer = queryMultiAdapter((obj, self.request), IDeserializeFromJson)
if deserializer is None:
return self.error(
"Not Implemented",
"Cannot deserialize type {}".format(obj.portal_type),
501,
)
try:
deserializer(data={fieldname: tus_upload}, create=mode == "create")
except DeserializationError as e:
return self.error("Deserialization Error", str(e), 400)
if temporarily_wrapped:
obj = aq_base(obj)
if mode == "create":
if not getattr(deserializer, "notifies_create", False):
notify(ObjectCreatedEvent(obj))
obj = add(self.context, obj)
tus_upload.close()
tus_upload.cleanup()
self.request.response.setHeader("Location", obj.absolute_url())
def render(self):
_files = {}
file_data = self.request.form['files[]']
file_name = file_data.filename
file_name = file_name.split('/')[-1].split('\\')[-1] # bug in old IE
file_name = clean_file_name(file_name)
_file_name = file_name + '_chunk'
logger.info('Staring chunk: ' + _file_name)
content_range = self.request['HTTP_CONTENT_RANGE']
content_type = mimetypes.guess_type(file_name)[0] or ""
for mutator in getAllUtilitiesRegisteredFor(IFileMutator):
file_name, file_data, content_type = mutator(
file_name, file_data, content_type)
if content_range:
""" don't do anything special if we only have one chunk """
max_size = int(content_range.split('/')[-1])
if file_data:
if _file_name in self.context.objectIds():
cf = self.context[_file_name]
cf.add_chunk(file_data,
file_name,
content_range,
graceful=True)
else:
self.context.invokeFactory('ChunkedFile', _file_name)
cf = self.context[_file_name]
cf.title = file_name
cf.add_chunk(file_data, file_name, content_range)
size = cf.currsize()
url = cf.absolute_url()
_files[file_name] = {
'name': file_name,
'size': size,
'url': url
}
if size == max_size:
if not QUIET_UPLOAD:
logger.info('Starting chunk merger')
nf_url = merge_chunks(self.context, cf, file_name)
_files[file_name]['url'] = nf_url
else:
nf = make_file(file_name, self.context, file_data)
primary_field = IPrimaryFieldInfo(nf)
_files[file_name] = {
'name': file_name,
'size': human_readable_size(primary_field.value.size),
'url': nf.absolute_url()
}
self.request.response.setHeader('Content-Type', 'application/json')
return json.dumps({'files': list(_files.values())})
def icon_class(self):
"""Gets the icon class for the primary field of this content"""
primary_field_info = IPrimaryFieldInfo(self.context)
if hasattr(primary_field_info.value, "contentType"):
contenttype = primary_field_info.value.contentType
icon_name = map_content_type(contenttype)
if icon_name:
return 'icon-file-{0}'.format(icon_name)
return 'icon-file-code'
def getObjSize_file(obj):
try:
primary_field_info = IPrimaryFieldInfo(obj)
except TypeError:
logger.warn(
u'Lookup of PrimaryField failed for {0} If renaming or importing '
u'please reindex!'.format(obj.absolute_url()))
return
return obj.getObjSize(None, primary_field_info.value.size)
def __new__(cls, context):
info = IPrimaryFieldInfo(context, None)
if info is None:
return None
filename = getattr(info.value, 'filename', None)
if not isinstance(filename, basestring) or not filename:
return None
instance = super(NameFromFileName, cls).__new__(cls)
instance.title = filename
return instance
def _render_nopreview(self, attachment):
primary_field = IPrimaryFieldInfo(attachment).value
mimetype = primary_field.contentType
data = primary_field.data
self.request.response.setHeader('content-type', mimetype)
self.request.response.setHeader(
'content-disposition', 'inline; '
'filename="{0}"'.format(
safe_unicode(self.attachment_id).encode('utf8')))
return data
def _get_url(self):
"""Compute the url to the content."""
url = self.context.absolute_url()
# add @@download to url if necessary, it is the case for dexterity files
try:
if IPrimaryFieldInfo(self.context):
url = u'{0}/@@download'.format(url)
except TypeError:
pass
return url + self.appendToUrl
def test_geticon_image(self):
from .test_image import dummy_image
primary_field_info = IPrimaryFieldInfo(self.image)
primary_field_info.field.set(self.image, dummy_image())
self.image.reindexObject()
brains = self.catalog.searchResults(dict(path="/plone/folder/image", ))
self.assertEqual('image.png', brains[0].getIcon)
def get_size(self):
"""Return the current size of the context in bytes.
"""
if ITrashed.providedBy(self.context):
return 0
primary_field_info = IPrimaryFieldInfo(self.context, None)
if not primary_field_info or not primary_field_info.value:
return 0
return primary_field_info.value.size
def scale(
self,
fieldname=None,
scale=None,
height=None,
width=None,
direction="thumbnail",
**parameters
):
if fieldname is None:
primary_field = IPrimaryFieldInfo(self.context, None)
if primary_field is None:
return # 404
fieldname = primary_field.fieldname
if scale is not None:
if width is not None or height is not None:
logger.warn(
"A scale name and width/heigth are given. Those are"
"mutually exclusive: solved by ignoring width/heigth and "
"taking name",
)
available = self.available_sizes
if scale not in available:
return None # 404
width, height = available[scale]
if IDisableCSRFProtection and self.request is not None:
alsoProvides(self.request, IDisableCSRFProtection)
storage = AnnotationStorage(
self.context,
functools.partial(self.modified, fieldname)
)
info = storage.scale(
fieldname=fieldname,
height=height,
width=width,
direction=direction,
scale=scale,
**parameters
)
if info is None:
return # 404
info["srcset"] = self.calculate_srcset(
fieldname=fieldname,
height=height,
width=width,
direction=direction,
scale=scale,
storage=storage,
**parameters
)
info["fieldname"] = fieldname
scale_view = self._scale_view_class(self.context, self.request, **info)
return scale_view
def _getFieldName(self, obj, fieldName):
if fieldName:
return fieldName
if IDexterityContent.providedBy(obj):
try:
primary = IPrimaryFieldInfo(obj)
return primary.fieldname
except TypeError:
log.error('No field specified and no primary field.')
return None
else:
return obj.getPrimaryField().getName()
def __new__(cls, context):
info = IPrimaryFieldInfo(context, None)
if info is None:
return None
filename = getattr(info.value, 'filename', None)
if not isinstance(filename, six.string_types) or not filename:
return None
instance = super(NameFromFileName, cls).__new__(cls)
instance.title = filename
if safe_hasattr(context, 'title') and not context.title:
context.title = filename
return instance
def get_primary_field_name(self):
fieldname = None
info = None
try:
info = IPrimaryFieldInfo(self.context, None)
except TypeError:
# No primary field present
pass
if info is not None:
fieldname = info.fieldname
elif base_hasattr(self.context, "getPrimaryField"):
field = self.context.getPrimaryField()
fieldname = field.getName()
return fieldname
def filename(obj):
try:
filename = obj.filename
if filename != Missing.Value:
return filename
except AttributeError:
pass
try:
info = IPrimaryFieldInfo(obj.getObject())
except TypeError:
return None
if info.value is None:
return None
return info.value.filename
