def new_folder(self, name, subpath=None):
""" Create a new collection ``name`` inside the folder ``subpath `` """
if self.is_readonly:
raise zExceptions.Forbidden(_('Connector is readonly'))
if not name:
raise ValueError(_('No name given'))
name = safe_unicode(name)
subpath = safe_unicode(subpath or self.subpath)
handle = self.context.get_handle(subpath)
if handle.exists(name):
msg = _('{}/{} already exists found').format(subpath, name)
self.messages.add(msg, 'error')
return self.request.response.redirect(self.context.absolute_url() + '/view/' + subpath)
try:
handle.makedir(name)
except Exception as e:
msg = _('{}/{} could not be created ({})').format(subpath, name, str(e))
self.messages.add(msg, 'error')
return self.request.response.redirect(self.context.absolute_url() + '/' + subpath)
msg = _('Created {}/{}').format(subpath, name)
self.messages.add(msg, 'info')
self.request.response.redirect(self.context.absolute_url() + '/view/' + subpath + '/' + name)
def remove(self, resource_name):
""" Remove a resource by path/name """
if self.is_readonly:
raise zExceptions.Forbidden(_('Connector is readonly'))
subpath = safe_unicode(self.request.get('subpath', self.subpath))
handle = self.context.get_handle()
if not handle.exists(resource_name):
msg = 'Not found {}'.format(resource_name)
raise zExceptions.NotFound(msg)
if handle.isdir(resource_name):
try:
handle.removetree(resource_name)
except Exception as e:
msg = resource_name + _(' could not be deleted') + ' ({})'.format(e)
self.request.response.setStatus(500)
return msg
elif handle.isfile(resource_name):
try:
handle.remove(resource_name)
except Exception as e:
msg = _('{} could not be deleted ({})').format(resource_name, e)
self.request.response.setStatus(500)
return msg
else:
msg = _('Unhandled file type for {}').format(resource_name)
raise RuntimeError(msg)
msg = _('Deleted {}').format(resource_name)
self.request.response.setStatus(200)
def rename(self, resource_name, new_name):
""" Rename a resource """
if self.is_readonly:
raise zExceptions.Forbidden(_('Connector is readonly'))
resource_name = safe_unicode(resource_name)
new_name = safe_unicode(new_name)
dirname = fs.path.dirname(resource_name)
new_resource_name = fs.path.join(dirname, new_name)
handle = self.context.get_handle()
if handle.exists(new_resource_name):
raise ValueError(_('Target {} exists').format(resource_name))
if handle.isfile(resource_name):
try:
handle.move(resource_name, new_resource_name)
except Exception as e:
msg = resource_name + _(' could not be moved') + ' ({})'.format(e)
self.request.response.setStatus(500)
return msg
else:
try:
fs.move.move_dir(handle, resource_name, handle, new_resource_name)
except Exception as e:
msg = resource_name + _(' could not be moved') + ' ({})'.format(e)
self.request.response.setStatus(500)
return msg
msg = _('Renamed {} to {}').format(resource_name, new_name)
self.request.response.setStatus(200)
def uploadBlobField(self, objtype, file='', filename='', mediadbStorable=True):
if objtype == _globals.DT_IMAGE:
clazz = MyImage
maxlength_prop = 'ZMS.input.image.maxlength'
elif objtype == _globals.DT_FILE:
clazz = MyFile
maxlength_prop = 'ZMS.input.file.maxlength'
blob = clazz(id='', title='', file=file)
blob.aq_parent = self
blob.mediadbfile = None
blob.filename = _fileutil.extractFilename(filename,
undoable=True).encode('utf-8')
# Check size.
if self is not None:
maxlength = self.getConfProperty(maxlength_prop, '')
if len(maxlength) > 0:
size = blob.get_size()
if size > int(maxlength):
raise zExceptions.Forbidden(
'size=%i > %s=%i' % (size, maxlength_prop, int(maxlength)))
# Store data in media-db.
if self is not None and mediadbStorable:
mediadb = self.getMediaDb()
if mediadb is not None:
blob.mediadbfile = mediadb.storeFile(blob)
blob.data = ''
return blob
def uploadBlobField(self, clazz, file=b'', filename=''):
try:
file = file.read()
except:
pass
mt, enc = standard.guess_content_type(filename, file)
if clazz in [_globals.DT_IMAGE, 'image'] or mt.startswith('image'):
clazz = MyImage
elif clazz in [_globals.DT_FILE, 'file']:
clazz = MyFile
blob = clazz(id='', title='', file=bytes('', 'utf-8'))
blob.update_data(file, content_type=mt, size=len(file))
blob.aq_parent = self
blob.mediadbfile = None
blob.filename = _fileutil.extractFilename(filename,
undoable=True).encode('utf-8')
# Check size.
if self is not None:
maxlength_prop = 'ZMS.input.%s.maxlength' % ['file', 'image'
][isinstance(
blob, MyImage)]
maxlength = self.getConfProperty(maxlength_prop, '')
if len(maxlength) > 0:
size = blob.get_size()
if size > int(maxlength):
raise zExceptions.Forbidden(
'size=%i > %s=%i' % (size, maxlength_prop, int(maxlength)))
return blob
def zip_import(self, zip_file=None):
""" Import subfolder from an uploaded ZIP file """
if self.is_readonly:
raise zExceptions.Forbidden(_('Connector is readonly'))
subpath = self.request.get('subpath') or self.subpath
handle = self.context.get_handle(subpath)
if not zip_file:
zip_filename = self.request.zipfile.filename
temp_fn = tempfile.mktemp(suffix='.zip')
with open(temp_fn, 'wb') as fp:
self.request.zipfile.seek(0)
fp.write(self.request.zipfile.read())
zip_file = temp_fn
else:
zip_filename = zip_file
if not zip_filename:
raise ValueError(u'No filename detected. Did you really upload a ZIP file?')
if not zip_filename.endswith('.zip'):
raise ValueError(u'Uploaded file did not end with .zip. Did you really upload a ZIP file?')
try:
with fs.zipfs.ZipFS(zip_file, encoding='utf-8') as zip_handle:
# import all files from ZIP into WebDAV
count = 0
dirs_created = set()
for i, name in enumerate(zip_handle.walk.files()):
target_filename = unicodedata.normalize('NFC', name).lstrip('/')
if self.subpath:
target_filename = u'{}/{}'.format(self.subpath, target_filename)
target_dirname = '/'.join(target_filename.split('/')[:-1])
if target_dirname not in dirs_created:
try:
handle.makedirs(target_dirname, recreate=True)
dirs_created.add(target_dirname)
except Exception as e:
LOG.error('Failed creating {} failed ({})'.format(target_dirname, e))
LOG.info(u'ZIP filename({})'.format(name))
out_fp = handle.open(target_filename, 'wb')
zip_fp = zip_handle.open(name, 'rb')
out_fp.write(zip_fp.read())
out_fp.close()
count += 1
except Exception as e:
msg = 'Error opening ZIP file: {}'.format(e)
raise
self.request.response.redirect(self.context.absolute_url() + '/view/' + subpath)
def zip_import_ui(self, zip_file=None, subpath=None, clean_directories=None):
""" Import WebDAV subfolder from an uploaded ZIP file """
if self.is_readonly:
raise zExceptions.Forbidden(_('Connector is readonly'))
try:
imported_files = self.zip_import(zip_file, subpath, clean_directories)
except Exception as e:
msg = u'ZIP import failed'
LOG.error(msg, exc_info=True)
return self.redirect(msg, 'error')
self.logger.log(
'ZIP file imported ({}, {} files)'.format(zip_file, len(imported_files)), details=imported_files)
return self.redirect(_(u'Uploaded ZIP archive imported'), subpath=subpath)
def upload_file(self):
""" AJAX callback for Uploadify """
if self.is_readonly:
raise zExceptions.Forbidden(_('Connector is readonly'))
subpath = safe_unicode(self.request.get('subpath', self.subpath))
filename = safe_unicode(os.path.basename(self.request.file.filename))
basename, ext = os.path.splitext(filename)
handle = self.context.get_handle(subpath)
with handle.open(filename, 'wb') as fp:
self.request.file.seek(0)
data = self.request.file.read()
fp.write(data)
self.request.response.setStatus(200)