def test_add_two_files(self):
ntypes = len(mimetypes.types_map)
content_types.add_files([MIME_TYPES_1, MIME_TYPES_2])
ctype, encoding = content_types.guess_content_type("foo.ztmt-1")
self.assert_(encoding is None)
self.assertEqual(ctype, "text/x-vnd.zope.test-mime-type-1")
ctype, encoding = content_types.guess_content_type("foo.ztmt-2")
self.assert_(encoding is None)
self.assertEqual(ctype, "text/x-vnd.zope.test-mime-type-2")
self.check_types_count(2)
def _get_content_type(self, file, body, id, content_type=None):
# Consult self.content_type first, this is either
# the default (unknown/unknown) or it got a value from a
# .metadata file
default_type = 'unknown/unknown'
if getattr(self, 'content_type', default_type) != default_type:
return self.content_type
# Next, look at file headers
headers=getattr(file, 'headers', None)
if headers and headers.has_key('content-type'):
content_type=headers['content-type']
else:
# Last resort: Use the (imperfect) content type guessing
# mechanism from OFS.Image, which ultimately uses the
# Python mimetypes module.
if not isinstance(body, basestring):
body = body.data
content_type, enc=guess_content_type(
getattr(file, 'filename',id), body, content_type)
if (enc is None
and (content_type.startswith('text/') or
content_type.startswith('application/'))
and body.startswith(codecs.BOM_UTF8)):
content_type += '; charset=utf-8'
return content_type
def _get_content_type(self, file, body, id, content_type=None):
# Consult self.content_type first, this is either
# the default (unknown/unknown) or it got a value from a
# .metadata file
default_type = 'unknown/unknown'
if getattr(self, 'content_type', default_type) != default_type:
return self.content_type
# Next, look at file headers
headers = getattr(file, 'headers', None)
if headers and headers.has_key('content-type'):
content_type = headers['content-type']
else:
# Last resort: Use the (imperfect) content type guessing
# mechanism from OFS.Image, which ultimately uses the
# Python mimetypes module.
if not isinstance(body, basestring):
body = body.data
content_type, enc = guess_content_type(
getattr(file, 'filename', id), body, content_type)
if (enc is None and (content_type.startswith('text/')
or content_type.startswith('application/'))
and body.startswith(codecs.BOM_UTF8)):
content_type += '; charset=utf-8'
return content_type
def _get_content_type(self, file, body, id, content_type=None):
headers=getattr(file, 'headers', None)
if headers and headers.has_key('content-type'):
content_type=headers['content-type']
else:
if type(body) is not type(''): body=body.data
content_type, enc=guess_content_type(
getattr(file, 'filename',id), body, content_type)
return content_type
def __init__(self, path, name):
self.path = path
f = open(path, 'rb')
data = f.read()
f.close()
self.content_type, enc = guess_content_type(path, data)
self.__name__ = name
self.lmt = float(os.path.getmtime(path)) or time()
self.lmh = rfc1123_date(self.lmt)
def __call__(self, name, content_type, data):
if not content_type and data:
content_type, width, height = getImageInfo(data)
if not content_type:
content_type, encoding = guess_content_type(name, data, '')
if content_type.startswith('image/'):
return Image(data)
return File(data, content_type)
def PUT_factory( self, name, typ, body ):
"""
Hook PUT creation to make objects of the right type when
new item uploaded via FTP/WebDAV.
"""
if typ is None:
typ, enc = guess_content_type()
if typ == 'text/x-python':
return PythonScript( name )
if typ[ :4 ] == 'text':
return DTMLMethod( '', __name__=name )
return None # take the default, then
def errors(self):
form = self.request.form
if "UPDATE_SUBMIT" in form:
filename = getattr(form["field.data"], "filename", None)
contenttype = form.get("field.contentType")
if filename:
if not contenttype:
contenttype = content_types.guess_content_type(filename)[0]
if not form.get("add_input_name"):
form["add_input_name"] = filename
return self.update_object(form["field.data"], contenttype)
return ''
def my_guess_content_type(path, data):
content_type, enc = guess_content_type(path, data)
if content_type in ('text/plain', 'text/html','text/x-unknown-content-type'):
if os.path.basename(path).endswith('.js-slimmed.js'):
content_type = 'application/x-javascript'
elif os.path.basename(path).find('.css-slimmed.css') > -1:
# the find() covers both 'foo.css-slimmed' and
# 'foo.css-slimmed-data64expanded'
content_type = 'text/css'
elif os.path.basename(path).find('.css-aliased.css') > -1:
content_type = 'text/css'
return content_type, enc
def __call__(self, client=None, REQUEST={}, RESPONSE=None, **kw):
"""Render the document given a client object, REQUEST mapping,
Response, and key word arguments."""
if not self._cache_namespace_keys:
data = self.ZCacheable_get(default=_marker)
if data is not _marker:
# Return cached results.
return data
__traceback_supplement__ = (PathTracebackSupplement, self)
kw['document_id'] =self.getId()
kw['document_title']=self.title
if hasattr(self, 'aq_explicit'):
bself=self.aq_explicit
else: bself=self
security=getSecurityManager()
security.addContext(self)
try:
if client is None:
# Called as subtemplate, so don't need error propigation!
r=apply(HTML.__call__, (self, bself, REQUEST), kw)
if RESPONSE is None: result = r
else: result = decapitate(r, RESPONSE)
if not self._cache_namespace_keys:
self.ZCacheable_set(result)
return result
r=apply(HTML.__call__, (self, (client, bself), REQUEST), kw)
if type(r) is not type('') or RESPONSE is None:
if not self._cache_namespace_keys:
self.ZCacheable_set(r)
return r
finally: security.removeContext(self)
have_key=RESPONSE.headers.has_key
if not (have_key('content-type') or have_key('Content-Type')):
if self.__dict__.has_key('content_type'):
c=self.content_type
else:
c, e=guess_content_type(self.__name__, r)
RESPONSE.setHeader('Content-Type', c)
result = decapitate(r, RESPONSE)
if not self._cache_namespace_keys:
self.ZCacheable_set(result)
return result
def __init__(self, path='', contentType=''):
self.path = path
_data = open(os.path.normpath(self.path), 'rb').read()
self._size = len(_data)
self._fileMode = 'rb'
self._encoding = DEFAULT_ENCODING
if contentType=='':
content_type, encoding = guess_content_type(self.path, _data, '')
if content_type.startswith('image/'):
self.contentType, width, height = getImageInfo(_data)
else:
self.contentType = content_type
if self.contentType.startswith('text/'):
self._fileMode = 'r'
if encoding:
self._encoding = encoding
def get_attachments(self, fields, request):
"""Return all attachments uploaded in form.
"""
from ZPublisher.HTTPRequest import FileUpload
try:
from zope.app.content_types import guess_content_type
except ImportError:
from OFS.content_types import guess_content_type
attachments = []
for field in fields:
if field.isFileField():
file = request.form.get('%s_file' % field.__name__, None)
if file and isinstance(file, FileUpload) and file.filename != '':
file.seek(0) # rewind
data = file.read()
filename = file.filename
mimetype, enc = guess_content_type(filename, data, None)
attachments.append((filename, mimetype, enc, data))
return attachments
def __init__(self, path, _prefix=None):
if _prefix is None:
_prefix = getConfiguration().softwarehome
elif type(_prefix) is not type(""):
_prefix = package_home(_prefix)
path = os.path.join(_prefix, path)
self.path = path
if Globals.DevelopmentMode:
# In development mode, a shorter time is handy
max_age = 60 # One minute
else:
# A longer time reduces latency in production mode
max_age = 3600 # One hour
self.cch = "public,max-age=%d" % max_age
data = open(path, "rb").read()
content_type, enc = guess_content_type(path, data)
if content_type:
self.content_type = content_type
else:
self.content_type = "image/%s" % path[path.rfind(".") + 1 :]
self.__name__ = path[path.rfind("/") + 1 :]
self.lmt = float(os.stat(path)[8]) or time.time()
self.lmh = rfc1123_date(self.lmt)
def PUT(self, REQUEST, RESPONSE):
"""Create a new non-collection resource.
"""
from ZServer import LARGE_FILE_THRESHOLD
self.dav__init(REQUEST, RESPONSE)
name = self.__name__
parent = self.__parent__
ifhdr = REQUEST.get_header('If', '')
if (IWriteLock.providedBy(parent) or
WriteLockInterface.isImplementedBy(parent)) and \
parent.wl_isLocked():
if ifhdr:
parent.dav__simpleifhandler(REQUEST, RESPONSE, col=1)
else:
# There was no If header at all, and our parent is locked,
# so we fail here
raise Locked
elif ifhdr:
# There was an If header, but the parent is not locked
raise PreconditionFailed
# SDS: Only use BODY if the file size is smaller than
# LARGE_FILE_THRESHOLD, otherwise read LARGE_FILE_THRESHOLD
# bytes from the file which should be enough to trigger
# content_type detection, and possibly enough for CMF's
# content_type_registry too.
#
# Note that body here is really just used for detecting the
# content type and figuring out the correct factory. The correct
# file content will be uploaded on ob.PUT(REQUEST, RESPONSE) after
# the object has been created.
#
# A problem I could see is content_type_registry predicates
# that do depend on the whole file being passed here as an
# argument. There's none by default that does this though. If
# they really do want to look at the file, they should use
# REQUEST['BODYFILE'] directly and try as much as possible not
# to read the whole file into memory.
if int(REQUEST.get('CONTENT_LENGTH') or 0) > LARGE_FILE_THRESHOLD:
file = REQUEST['BODYFILE']
body = file.read(LARGE_FILE_THRESHOLD)
file.seek(0)
else:
body = REQUEST.get('BODY', '')
typ=REQUEST.get_header('content-type', None)
if typ is None:
typ, enc = guess_content_type(name, body)
factory = getattr(parent, 'PUT_factory', self._default_PUT_factory )
ob = factory(name, typ, body)
if ob is None:
ob = self._default_PUT_factory(name, typ, body)
# We call _verifyObjectPaste with verify_src=0, to see if the
# user can create this type of object (and we don't need to
# check the clipboard.
try:
parent._verifyObjectPaste(ob.__of__(parent), 0)
except CopyError:
raise Unauthorized, sys.exc_info()[1]
# Delegate actual PUT handling to the new object,
# SDS: But just *after* it has been stored.
self.__parent__._setObject(name, ob)
ob = self.__parent__._getOb(name)
ob.PUT(REQUEST, RESPONSE)
RESPONSE.setStatus(201)
RESPONSE.setBody('')
return RESPONSE
def PUT(self, REQUEST, RESPONSE):
""" Create a new non-collection resource, deleting the LockNull
object from the container before putting the new object in. """
self.dav__init(REQUEST, RESPONSE)
name = self.__name__
parent = self.aq_parent
parenturl = parent.absolute_url()
ifhdr = REQUEST.get_header('If', '')
# Since a Lock null resource is always locked by definition, all
# operations done by an owner of the lock that affect the resource
# MUST have the If header in the request
if not ifhdr:
raise PreconditionFailed, 'No If-header'
# First we need to see if the parent of the locknull is locked, and
# if the user owns that lock (checked by handling the information in
# the If header).
if (IWriteLock.providedBy(parent) or
WriteLockInterface.isImplementedBy(parent)) and \
parent.wl_isLocked():
itrue = parent.dav__simpleifhandler(REQUEST, RESPONSE, 'PUT',
col=1, url=parenturl,
refresh=1)
if not itrue:
raise PreconditionFailed, (
'Condition failed against resources parent')
# Now we need to check the If header against our own lock state
itrue = self.dav__simpleifhandler(REQUEST, RESPONSE, 'PUT', refresh=1)
if not itrue:
raise PreconditionFailed, (
'Condition failed against locknull resource')
# All of the If header tests succeeded, now we need to remove ourselves
# from our parent. We need to transfer lock state to the new object.
locks = self.wl_lockItems()
parent._delObject(name)
# Now we need to go through the regular operations of PUT
body = REQUEST.get('BODY', '')
typ = REQUEST.get_header('content-type', None)
if typ is None:
typ, enc = guess_content_type(name, body)
factory = getattr(parent, 'PUT_factory', self._default_PUT_factory)
ob = (factory(name, typ, body) or
self._default_PUT_factory(name, typ, body))
# Verify that the user can create this type of object
try:
parent._verifyObjectPaste(ob.__of__(parent), 0)
except Unauthorized:
raise
except:
raise Forbidden, sys.exc_info()[1]
# Put the locks on the new object
if not (IWriteLock.providedBy(ob) or
WriteLockInterface.isImplementedBy(ob)):
raise MethodNotAllowed, (
'The target object type cannot be locked')
for token, lock in locks:
ob.wl_setLock(token, lock)
# Delegate actual PUT handling to the new object.
ob.PUT(REQUEST, RESPONSE)
parent._setObject(name, ob)
RESPONSE.setStatus(201)
RESPONSE.setBody('')
return RESPONSE
def __call__(self, client=None, REQUEST={}, RESPONSE=None, **kw):
"""Render the document given a client object, REQUEST mapping,
Response, and key word arguments."""
if not self._cache_namespace_keys:
data = self.ZCacheable_get(default=_marker)
if data is not _marker:
if ( IStreamIterator.isImplementedBy(data) and
RESPONSE is not None ):
# This is a stream iterator and we need to set some
# headers now before giving it to medusa
if RESPONSE.headers.get('content-length', None) is None:
RESPONSE.setHeader('content-length', len(data))
if ( RESPONSE.headers.get('content-type', None) is None and
RESPONSE.headers.get('Content-type', None) is None ):
ct = ( self.__dict__.get('content_type') or
self.default_content_type )
RESPONSE.setHeader('content-type', ct)
# Return cached results.
return data
__traceback_supplement__ = (PathTracebackSupplement, self)
kw['document_id'] =self.getId()
kw['document_title']=self.title
security=getSecurityManager()
security.addContext(self)
if self.__dict__.has_key('validate'):
first_time_through = 0
else:
self.__dict__['validate'] = security.DTMLValidate
first_time_through = 1
try:
if client is None:
# Called as subtemplate, so don't need error propagation!
r=apply(HTML.__call__, (self, client, REQUEST), kw)
if RESPONSE is None: result = r
else: result = decapitate(r, RESPONSE)
if not self._cache_namespace_keys:
self.ZCacheable_set(result)
return result
r=apply(HTML.__call__, (self, client, REQUEST), kw)
if type(r) is not type('') or RESPONSE is None:
if not self._cache_namespace_keys:
self.ZCacheable_set(r)
return r
finally:
security.removeContext(self)
if first_time_through:
del self.__dict__['validate']
have_key=RESPONSE.headers.has_key
if not (have_key('content-type') or have_key('Content-Type')):
if self.__dict__.has_key('content_type'):
c=self.content_type
else:
c, e=guess_content_type(self.getId(), r)
RESPONSE.setHeader('Content-Type', c)
result = decapitate(r, RESPONSE)
if not self._cache_namespace_keys:
self.ZCacheable_set(result)
return result
