class csvreplicataTool(UniqueObject, BaseContent, BrowserDefaultMixin):
"""
"""
security = ClassSecurityInfo()
implements(interfaces.IcsvreplicataTool)
meta_type = 'csvreplicataTool'
_at_rename_after_creation = True
schema = csvreplicataTool_schema
handlers = PersistentMapping
##code-section class-header #fill in your manual code here
##/code-section class-header
# tool-constructors have no id argument, the id is fixed
def __init__(self, id=None):
BaseContent.__init__(self,'portal_csvreplicatatool')
self.setTitle('')
##code-section constructor-footer #fill in your manual code here
self.setTitle('CSV Replicator tool')
self.replicabletypes = PersistentMapping()
self.handlers = {}
##/code-section constructor-footer
@property
def dreplicabletypes(self):
return dict(self.replicabletypes)
def manage_afterAdd(self, item, container):
""" initialize handlers with appconfig HANDLERS values"""
self.handlers = HANDLERS
# tool should not appear in portal_catalog
def at_post_edit_script(self):
self.unindexObject()
##code-section post-edit-method-footer #fill in your manual code here
##/code-section post-edit-method-footer
# Methods
# Manually created methods
def setCSVsettings(self, REQUEST):
"""
"""
self.setEncoding(REQUEST.get('encoding'));
self.setDelimiter(REQUEST.get('delimiter'));
self.setServerfilepath(REQUEST.get('serverfilepath'));
self.setDateTimeFormat(REQUEST.get('datetimeformat'));
self.setTempPath(REQUEST.get('tempPath'))
self.setPlainFormat(REQUEST.get('is_plain_format', '') == 'on')
self.setPartialCommitNumber(int(REQUEST.get('partial_commit_number', '')))
# Redirection of the page now that the treatment is done
REQUEST.RESPONSE.redirect(self.absolute_url()+'/csv_settings')
def setCSVHandledTypes(self, REQUEST):
"""
"""
types_tool = getToolByName(self, 'archetype_tool')
# Get of the various replicabletypes current and new)
newreplicabletypes = REQUEST.get('csvhandledtypes')
if (not type(newreplicabletypes) is list):
newreplicabletypes = [newreplicabletypes]
currentreplicablestypes = self.replicabletypes
# Addition of the new replicable types, by default a new empty list
# and creation of a temp variable to hold the new csv handled types
newreplicabletypestempdict = {}
for t in newreplicabletypes :
newreplicabletypestempdict[t] = []
if (not currentreplicablestypes.has_key(t)):
currentreplicablestypes[t] = ['default', ]
# removal of the types that are not anymore replicables
for k, v in currentreplicablestypes.items():
if (not newreplicabletypestempdict.has_key(k)):
del currentreplicablestypes[k]
# save of the new values
self.replicabletypes.update(currentreplicablestypes)
# Redirection of the page now that the treatment is done
REQUEST.RESPONSE.redirect(self.absolute_url()+'/csv_settings')
def setExcludedFields(self, REQUEST):
"""
"""
self.setExcludedfieldsclasses(
REQUEST.get('excludedfieldsclasses').split('\n'));
self.setExcludedfields(REQUEST.get('excludedfields').split('\n'));
# Redirection of the page now that the treatment is done
REQUEST.RESPONSE.redirect(self.absolute_url()+'/csv_settings')
def getPortalTypeNames(self):
"""
"""
l = getPortalTypes(self).keys()
l.sort()
return [(k, k) for k in l]
def getReplicableTypesSorted(self):
"""
"""
l = self.replicabletypes.keys()
l.sort()
return l
def getTypeSchematas(self, type):
"""
"""
attool = getToolByName(self, 'archetype_tool')
pt = getPortalTypes(self)
if pt.has_key(type):
(package, name) = pt[type]
t = attool.lookupType(package, name)
return t['klass'].schema.getSchemataNames()
else:
return []
def setCSVHandledTypesSchematas(self, REQUEST):
"""
"""
currentreplicablestypes = self.replicabletypes
i = 0
for ptn in self.getReplicableTypesSorted():
i += 1
if (type(ptn) is tuple):
t = ptn[0]
else:
t = ptn
r = REQUEST.get('csvhandledschematas-'+str(i))
if r:
if (not type(r) is list):
r = [r]
currentreplicablestypes[t] = r
else :
if currentreplicablestypes.has_key(t):
del currentreplicablestypes[t]
self.replicabletypes.update(currentreplicablestypes)
# Redirection of the page now that the treatment is done
REQUEST.RESPONSE.redirect(self.absolute_url()+'/csv_settings')
def clearReplicableTypes(self):
"""
"""
self.replicabletypes.clear()
def printReplicableTypes(self):
"""
"""
return self.replicabletypes
def getHandlers(self):
"""
"""
if not getattr(self, 'handlers', None):
setattr(self, 'handlers', {})
# migrate persistent mapping with possible new values
for h in HANDLERS:
if not h in self.handlers:
self.handlers[h] = HANDLERS[h]
return self.handlers
def setHandler(self, key, value):
"""
"""
self.handlers[key] = value
def delHandler(self, key):
"""
"""
del(self.handlers[key])
def getNonExportableFields(self):
return (self.getExcludedfields()
+ ('tableContents',))
def fullactivation(self):
types = getPortalTypes(self)
self.replicabletypes.update(
dict(
[(t, self.getTypeSchematas(t))
for t in types])
)
class PloneboardTool(UniqueObject, Folder, ActionProviderBase):
implements(IPloneboardTool)
id = PLONEBOARD_TOOL
meta_type = 'Ploneboard Tool'
security = ClassSecurityInfo()
def __init__(self):
self.transforms = PersistentMapping()
self.enable_anon_name = False
security.declarePrivate('registerTransform')
def registerTransform(self, name, module, friendlyName=None):
tr_tool = getToolByName(self, 'portal_transforms')
if name not in tr_tool.objectIds():
tr_tool.manage_addTransform(name, module)
wasAdded = True
else:
wasAdded = False
if not friendlyName:
friendlyName = name
if name not in self.transforms:
self.transforms[name] = {
'enabled': True,
'friendlyName': friendlyName,
'wasAdded': wasAdded
}
security.declarePrivate('unregisterTransform')
def unregisterTransform(self, name):
tr_tool = getToolByName(self, 'portal_transforms')
if self.transforms[name]['wasAdded']:
try:
tr_tool._delObject(name)
except AttributeError as e:
pass
del self.transforms[name]
security.declareProtected(ManagePortal, 'enableTransform')
def enableTransform(self, name, enabled=True):
"""Change the activity status for a transform."""
self.transforms[name]['enabled'] = enabled
security.declarePrivate('unregisterAllTransforms')
def unregisterAllTransforms(self):
tr_tool = getToolByName(self, 'portal_transforms')
for transform_name in self.getTransforms():
if not self.transforms[transform_name] or \
self.transforms[transform_name].get('wasAdded', False):
try:
tr_tool._delObject(transform_name)
except AttributeError:
pass
self.transforms.clear()
security.declareProtected(ManagePortal, 'getTransforms')
def getTransforms(self):
"""Returns list of transform names."""
return list(self.transforms.keys())
security.declareProtected(ManagePortal, 'getTransformFriendlyName')
def getTransformFriendlyName(self, name):
"""Returns a friendly name for the given transform."""
return self.transforms[name]['friendlyName']
security.declareProtected(View, 'getEnabledTransforms')
def getEnabledTransforms(self):
"""Returns list of names for enabled transforms"""
return [
name for name in list(self.transforms.keys())
if self.transforms[name]['enabled']
]
security.declareProtected(View, 'performCommentTransform')
def performCommentTransform(self, orig, **kwargs):
"""This performs the comment transform - also used for preview."""
transform_tool = getToolByName(self, 'portal_transforms')
content_type = kwargs.get("content_type", "text/plain")
# This one is very important, because transform object has no
# acquisition context inside it, so we need to pass it our one
context = kwargs.get('context', self)
data = transform_tool._wrap(content_type)
for transform in self.getEnabledTransforms():
data = transform_tool.convert(transform, orig, data, context)
orig = data.getData()
return orig
# File upload - should be in a View once we get formcontroller support in Views
security.declareProtected(View, 'getUploadedFiles')
def getUploadedFiles(self):
request = self.REQUEST
result = []
files = request.get('files', [])
if not files:
return []
sdm = getToolByName(self, 'session_data_manager', None)
if sdm is not None:
pt = getToolByName(self, 'plone_utils')
hassession = sdm.hasSessionData()
for file in files:
if isinstance(file, str) and hassession:
# Look it up from session
oldfile = request.SESSION.get(file, None)
if oldfile is not None:
result.append(oldfile)
if isinstance(file, FileUpload):
if file:
filename = file.filename.split('\\')[-1]
id = pt.normalizeString(filename)
ct = file.headers.getheader('content-type')
if ct is None:
ct = ''
newfile = File(id, id, file, ct)
request.SESSION[id] = newfile
result.append(newfile)
# delete files form session if not referenced
new_filelist = [x.getId() for x in result]
old_filelist = hassession and request.SESSION.get(
'ploneboard_uploads', []) or []
for removed in [f for f in old_filelist if f not in new_filelist]:
del request.SESSION[f]
if hassession or new_filelist:
request.SESSION['ploneboard_uploads'] = new_filelist
return result
security.declareProtected(View, 'clearUploadedFiles')
def clearUploadedFiles(self):
# Get previously uploaded files with a reference in request
# + files uploaded in this request
# XXX Add variable to keep track of filenames?
request = self.REQUEST
sdm = getToolByName(self, 'session_data_manager', None)
if sdm is not None:
if sdm.hasSessionData():
old_filelist = request.SESSION.get('ploneboard_uploads', None)
if old_filelist is not None:
for file in old_filelist:
if file in request.SESSION:
del request.SESSION[file]
del request.SESSION['ploneboard_uploads']
security.declareProtected(View, 'getEnableAnonName')
def getEnableAnonName(self):
"""Returns if anonymous can insert a name in their comments."""
return self.enable_anon_name
security.declareProtected(ManagePortal, 'setEnableAnonName')
def setEnableAnonName(self, value):
"""Set if anonymous can insert a name in their comments."""
self.enable_anon_name = value
class csvreplicataTool(UniqueObject, BaseContent, BrowserDefaultMixin):
"""
"""
security = ClassSecurityInfo()
implements(interfaces.IcsvreplicataTool)
meta_type = 'csvreplicataTool'
_at_rename_after_creation = True
schema = csvreplicataTool_schema
handlers = PersistentMapping
##code-section class-header #fill in your manual code here
##/code-section class-header
# tool-constructors have no id argument, the id is fixed
def __init__(self, id=None):
BaseContent.__init__(self, 'portal_csvreplicatatool')
self.setTitle('')
##code-section constructor-footer #fill in your manual code here
self.setTitle('CSV Replicator tool')
self.replicabletypes = PersistentMapping()
self.handlers = {}
##/code-section constructor-footer
@property
def dreplicabletypes(self):
return dict(self.replicabletypes)
def manage_afterAdd(self, item, container):
""" initialize handlers with appconfig HANDLERS values"""
self.handlers = HANDLERS
# tool should not appear in portal_catalog
def at_post_edit_script(self):
self.unindexObject()
##code-section post-edit-method-footer #fill in your manual code here
##/code-section post-edit-method-footer
# Methods
# Manually created methods
def setCSVsettings(self, REQUEST):
"""
"""
self.setEncoding(REQUEST.get('encoding'))
self.setDelimiter(REQUEST.get('delimiter'))
self.setServerfilepath(REQUEST.get('serverfilepath'))
self.setDateTimeFormat(REQUEST.get('datetimeformat'))
self.setTempPath(REQUEST.get('tempPath'))
self.setPlainFormat(REQUEST.get('is_plain_format', '') == 'on')
self.setPartialCommitNumber(
int(REQUEST.get('partial_commit_number', '')))
# Redirection of the page now that the treatment is done
REQUEST.RESPONSE.redirect(self.absolute_url() + '/csv_settings')
def setCSVHandledTypes(self, REQUEST):
"""
"""
types_tool = getToolByName(self, 'archetype_tool')
# Get of the various replicabletypes current and new)
newreplicabletypes = REQUEST.get('csvhandledtypes')
if (not type(newreplicabletypes) is list):
newreplicabletypes = [newreplicabletypes]
currentreplicablestypes = self.replicabletypes
# Addition of the new replicable types, by default a new empty list
# and creation of a temp variable to hold the new csv handled types
newreplicabletypestempdict = {}
for t in newreplicabletypes:
newreplicabletypestempdict[t] = []
if (not currentreplicablestypes.has_key(t)):
currentreplicablestypes[t] = [
'default',
]
# removal of the types that are not anymore replicables
for k, v in currentreplicablestypes.items():
if (not newreplicabletypestempdict.has_key(k)):
del currentreplicablestypes[k]
# save of the new values
self.replicabletypes.update(currentreplicablestypes)
# Redirection of the page now that the treatment is done
REQUEST.RESPONSE.redirect(self.absolute_url() + '/csv_settings')
def setExcludedFields(self, REQUEST):
"""
"""
self.setExcludedfieldsclasses(
REQUEST.get('excludedfieldsclasses').split('\n'))
self.setExcludedfields(REQUEST.get('excludedfields').split('\n'))
# Redirection of the page now that the treatment is done
REQUEST.RESPONSE.redirect(self.absolute_url() + '/csv_settings')
def getPortalTypeNames(self):
"""
"""
l = getPortalTypes(self).keys()
l.sort()
return [(k, k) for k in l]
def getReplicableTypesSorted(self):
"""
"""
l = self.replicabletypes.keys()
l.sort()
return l
def getTypeSchematas(self, type):
"""
"""
attool = getToolByName(self, 'archetype_tool')
pt = getPortalTypes(self)
if pt.has_key(type):
(package, name) = pt[type]
t = attool.lookupType(package, name)
return t['klass'].schema.getSchemataNames()
else:
return []
def setCSVHandledTypesSchematas(self, REQUEST):
"""
"""
currentreplicablestypes = self.replicabletypes
i = 0
for ptn in self.getReplicableTypesSorted():
i += 1
if (type(ptn) is tuple):
t = ptn[0]
else:
t = ptn
r = REQUEST.get('csvhandledschematas-' + str(i))
if r:
if (not type(r) is list):
r = [r]
currentreplicablestypes[t] = r
else:
if currentreplicablestypes.has_key(t):
del currentreplicablestypes[t]
self.replicabletypes.update(currentreplicablestypes)
# Redirection of the page now that the treatment is done
REQUEST.RESPONSE.redirect(self.absolute_url() + '/csv_settings')
def clearReplicableTypes(self):
"""
"""
self.replicabletypes.clear()
def printReplicableTypes(self):
"""
"""
return self.replicabletypes
def getHandlers(self):
"""
"""
if not getattr(self, 'handlers', None):
setattr(self, 'handlers', {})
# migrate persistent mapping with possible new values
for h in HANDLERS:
if not h in self.handlers:
self.handlers[h] = HANDLERS[h]
return self.handlers
def setHandler(self, key, value):
"""
"""
self.handlers[key] = value
def delHandler(self, key):
"""
"""
del (self.handlers[key])
def getNonExportableFields(self):
return (self.getExcludedfields() + ('tableContents', ))
def fullactivation(self):
types = getPortalTypes(self)
self.replicabletypes.update(
dict([(t, self.getTypeSchematas(t)) for t in types]))
