class Config(Base):
"This is the basic config class"
security = ClassSecurityInfo()
meta_type = 'Config'
configureable = 0
security.declarePrivate('__init__')
def __init__(self, id, dict=None):
"Initialize the class"
self.id = id
if dict is not None and hasattr(dict, 'items'):
for i, j in dict.items():
if isinstance(j, types.DictType):
self.addEntry(i, j)
security.declarePrivate('addEntry')
def addEntry(self, name, dict):
"Add an entry to this config"
if name == 'id':
name = 'showId'
self.setObject(name, Entry(name, dict))
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.removeData()
self.setParentObjectConfig()
security.declarePrivate('setParentObjectConfig')
def setParentObjectConfig(self):
"set the parent objectConfig"
self.aq_parent.setObject('objectConfig', self.convertToDict())
setParentObjectConfig = utility.upgradeLimit(setParentObjectConfig, 141)
security.declarePrivate('removeData')
def removeData(self):
"remove the data member of this object"
if 'data' in self.__dict__:
if hasattr(self.data, 'items'):
for key, object in self.data.items():
if key == 'id':
key = 'showId'
if hasattr(object, 'meta_type') and object.meta_type == 'Entry':
self.setObject(key, object)
getattr(self, key).upgrader()
else:
self.addEntry(key, object)
self.delObjects(['data'])
removeData = utility.upgradeLimit(removeData, 141)
security.declarePrivate('convertToDict')
def convertToDict(self):
"Convert this object to the new dict config format"
temp = {}
for name, entry in self.objectItems('Entry'):
temp[name] = entry.value
return temp
class Button(UserObject):
"Input text class"
meta_type = "Button"
security = ClassSecurityInfo()
overwrite = 1
buttonTitle = "Submit Changes"
classConfig = {'buttonTitle': {'name': 'Button Title', 'type': 'string'}}
updateReplaceList = ('buttonTitle', )
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit short object"
return self.create_button(self.buttonTitle, self.buttonTitle)
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.getTitleFromObjectConfig()
security.declarePrivate('getTitleFromObjectConfig')
def getTitleFromObjectConfig(self):
"if we have objectConfig try and get the title from it and use it for the button title"
if 'objectConfig' in self.__dict__:
self.setObject('buttonTitle', self.objectConfig['title'])
del self.objectConfig['title']
getTitleFromObjectConfig = utility.upgradeLimit(getTitleFromObjectConfig,
141)
class MultiSimpleEmbed(SimpleEmbed, MixAddRegistered):
"uses a container to give access to a view of many compounddocs using simpleembed"
meta_type = "MultiSimpleEmbed"
security = ClassSecurityInfo()
editDisplayName = ''
viewDisplayName = ''
security.declarePrivate('instance')
instance = (('CreationAssistant',('create', 'CreationAssistant')),)
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"This is the basic search function"
return ''
classConfig = {}
classConfig['editDisplayName'] = {'name':'Display for editing:', 'type':'string'}
classConfig['viewDisplayName'] = {'name':'Display for viewing:', 'type':'string'}
classConfig['path'] = {'name':'Path:', 'type':'string'}
security.declarePrivate('observerUpdate')
def observerUpdate(self, object=None):
"Process what you were observing"
object = self.getCompoundDoc().restrictedTraverse(self.path,None)
useObjects = object.getUseObjects()
simplemethodobjects = self.objectValues('SimpleEmbed')
if object:
if useObjects is not None:
for i in useObjects:
path = i.getPath()
if not hasattr(aq_base(self), path):
embed = SimpleEmbed(path)
embed.path = path
self.setObject(path, embed)
else:
self.delObjects(self.objectIds('SimpleEmbed'))
return None
useObjects = object.getUseObjects()
if useObjects is not None:
paths = [i.getPath() for i in useObjects]
for embed in simplemethodobjects:
if embed.embedded() is not None:
path = embed.getId()
if path not in paths:
self.delObjects([path])
else:
self.delObjects([embed.getId()])
def after_manage_edit(self, dict):
"Process edits."
try:
object = self.getCompoundDoc().restrictedTraverse(self.path)
except KeyError:
object = None
if object is not None:
object.observerAttached(self)
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit view"
self.setDrawMode('edit')
format = '<p>ID:%s</p> %s'
return ''.join([format % (id, object.edit()) for id,object in self.objectItems('SimpleEmbed')])
security.declareProtected('View', 'view')
def view(self):
"Inline draw view"
object = self.getCompoundDoc().restrictedTraverse(self.path,None)
if object is not None and object.limitOkay():
return ''.join([object.view() for object in self.objectValues('SimpleEmbed')])
return ''
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.removeOldAttributes()
self.fixupObservation()
security.declarePrivate('removeOldAttributes')
def removeOldAttributes(self):
"remove attributes that are no longer needed"
self.delObjects(['editDTML', 'viewDTML', 'CreationAssistantString'])
removeOldAttributes = utility.upgradeLimit(removeOldAttributes, 141)
security.declarePrivate('fixupObservation')
def fixupObservation(self):
"fix the observation stuff"
try:
object = self.getCompoundDoc().restrictedTraverse(self.path)
except KeyError:
object = None
if object is not None:
object.observerAttached(self)
if object.inuse == []:
self.delObjects(self.objectIds('SimpleEmbed'))
fixupObservation = utility.upgradeLimit(fixupObservation, 141)
class DisplayManager(base.Base):
"DisplayManager manages all displays"
meta_type = "DisplayManager"
security = ClassSecurityInfo()
overwrite = 1
data = ''
defaultEdit = ''
defaultView = ''
get_default = {'edit': 'defaultEdit', 'view': 'defaultView'}
usageMapping = None
security.declarePrivate('render')
def render(self, purpose, display=None):
"Please render an item with this purpose"
get_default = self.get_default
try:
return getattr(self, display).view()
except (AttributeError, TypeError):
pass
try:
return getattr(self, getattr(self, get_default[purpose])).view()
except (AttributeError, KeyError):
pass
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit view"
temp = [self.addDeleteObjectsEdit()]
editDisplays = self.displayUsage('edit')
if editDisplays:
temp.append(
'<p>Default Display for editing: %s</p>' % self.option_select(
editDisplays, 'defaultEdit', [self.defaultEdit]))
viewDisplays = self.displayUsage('view')
if viewDisplays:
temp.append(
'<p>Default Display for viewing: %s</p>' % self.option_select(
viewDisplays, 'defaultView', [self.defaultView]))
return ''.join(temp)
security.declarePrivate('restrictedUserObject')
def restrictedUserObject(self):
"Return a list of the types that are allowed to be added or deleted from this object by a user"
return ['Display']
security.declarePrivate('displayUsage')
def displayUsage(self, usage):
"Return all objects that match this usage"
if self.usageMapping is None:
return []
return self.usageMapping.get(usage, [])
security.declarePrivate('performUpdate')
def performUpdate(self):
"Update object to newest version"
if not self.checkShared():
super(DisplayManager, self).performUpdate()
security.declarePrivate('performUpgrade')
def performUpgrade(self):
"perform the upgrade on this object and its children"
if not self.checkShared():
super(DisplayManager, self).performUpgrade()
security.declarePrivate('beforeProfileLoad')
def beforeProfileLoad(self):
"run this action before loading the object with profile information"
self.delObjects(self.objectIds('Display'))
self.performUpdate()
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.removeBadEditName()
self.fixupCurrentEdit()
for i in self.objectValues('Display'):
i.performUpgrade()
self.fixupDefaultEdit()
self.fixupDefaultView()
self.addUsageMapping()
self.fixedDefaultDisplay()
security.declarePrivate('fixupDefaultEdit')
def fixupDefaultEdit(self):
"fix the defaultEdit attribute"
if self.defaultEdit == '':
temp = self.displayUsage('edit')
if len(temp):
self.setObject('defaultEdit', temp[0])
fixupDefaultEdit = utility.upgradeLimit(fixupDefaultEdit, 141)
security.declarePrivate('fixupDefaultView')
def fixupDefaultView(self):
"fixup the defaultView attribute"
if self.defaultView == '':
temp = self.displayUsage('view')
if len(temp):
self.setObject('defaultView', temp[0])
fixupDefaultView = utility.upgradeLimit(fixupDefaultView, 141)
security.declarePrivate('fixupCurrentEdit')
def fixupCurrentEdit(self):
"remove the currentEdit attribute"
if 'currentEdit' in self.__dict__:
self.delObjects(['currentEdit'])
fixupCurrentEdit = utility.upgradeLimit(fixupCurrentEdit, 141)
security.declarePrivate('removeBadEditName')
def removeBadEditName(self):
"remvoe a bad edit name from this object"
badName = self.getId() + 'edit'
if badName in self.__dict__:
self.delObjects([badName])
removeBadEditName = utility.upgradeLimit(removeBadEditName, 141)
security.declarePrivate('addUsageMapping')
def addUsageMapping(self):
"""add a usage mapping object to look up usages faster and so displays don't need to
be opened that are not needed should reduce memory usage and increase speed at the
cost of a little disk space"""
if self.usageMapping is None:
self.usageMapping = {}
for name, display in self.objectItems('Display'):
self.usageMapping.setdefault(display.usage, []).append(name)
self._p_changed = 1
addUsageMapping = utility.upgradeLimit(addUsageMapping, 144)
security.declarePrivate('fixDefaultDisplay')
def fixedDefaultDisplay(self):
"fix the defaultEdit and defaultView items if they are set to non existant items"
if self.defaultEdit and self.defaultEdit not in self.usageMapping.get(
'edit', []):
self.setObject('defaultEdit', '')
if self.defaultView and self.defaultView not in self.usageMapping.get(
'view', []):
self.setObject('defaultView', '')
self.setAutoDisplay()
fixedDefaultDisplay = utility.upgradeLimit(fixedDefaultDisplay, 145)
security.declarePrivate('afterDeleteRegisteredObject')
def afterDeleteRegisteredObject(self, name):
"do something after a registered object is deleted"
for defaultDisplay in self.get_default.itervalues():
if name == getattr(self, defaultDisplay):
self.setObject(defaultDisplay, '')
self.removeMapping(name)
self.setAutoDisplay()
security.declarePrivate('removeMapping')
def removeMapping(self, name):
"remove a mapping item"
for usage, displays in self.usageMapping.iteritems():
if name in displays:
displays.remove(name)
self._p_changed = 1
security.declarePrivate('addMapping')
def addMapping(self, name):
"add a mapping"
display = getattr(self, name)
if self.usageMapping is None:
self.usageMapping = {}
displayUsage = display.usage
displays = self.usageMapping.setdefault(displayUsage, [])
if name not in displays:
displays.append(name)
self._p_changed = 1
for usage, displays in self.usageMapping.iteritems():
if usage != displayUsage and name in displays:
displays.remove(name)
self._p_changed = 1
security.declarePrivate('cleanupDefaultDisplays')
def cleanupDefaultDisplays(self, display):
"make sure our default displays exist and are for the usage they have been set for"
for usage, defaultDisplay in self.get_default.iteritems():
displayName = getattr(self, defaultDisplay)
if displayName == display.getId() and usage != display.usage:
self.setObject(defaultDisplay, '')
self.setAutoDisplay()
#need to check if an item currently being g =used is missing or non existent
#and then see if any of our current items could do that job
security.declarePrivate("setAutoDisplay")
def setAutoDisplay(self):
"set the default filter to a filter if one is not already set"
for usage, defaultDisplay in self.get_default.iteritems():
displayName = getattr(self, defaultDisplay)
if not displayName:
displays = self.displayUsage(usage)
if displays:
self.setObject(defaultDisplay, displays[0])
security.declarePrivate('checkShared')
def checkShared(self):
"return true if we are in a shared object"
cdoc = self.getCompoundDoc()
return cdoc.masterLocation is not None and cdoc.masterLocation != cdoc.getPath(
)
class Entry(Base):
"This is the entry class"
security = ClassSecurityInfo()
meta_type = 'Entry'
configureable = 0
security.declarePrivate('__init__')
def __init__(self, id, dict=None):
self.id = id
self.name = ""
self.value = ""
if dict:
for i, j in dict.items():
self.setObject(i, j)
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.cleanupData()
self.cleanupId()
self.upgraderEntryType()
self.cleanupType()
self.cleanupValues()
security.declarePrivate('upgraderEntryType')
def upgraderEntryType(self):
"upgrade config objects to use the optional type system"
try:
config = self.aq_parent.aq_parent.classConfig
except AttributeError:
return None
id = self.getId()
if id in config and 'type' in config[id] and getattr(
self, 'type', None) != config[id]['type']:
self.setObject('type', config[id]['type'])
upgraderEntryType = utility.upgradeLimit(upgraderEntryType, 141)
security.declarePrivate('cleanupData')
def cleanupData(self):
"clean up the data attribute"
if 'data' in self.__dict__:
if hasattr(self.data, 'items'):
for key, object in self.data.items():
self.setObject(key, object)
del self.data
cleanupData = utility.upgradeLimit(cleanupData, 141)
security.declarePrivate('cleanupId')
def cleanupId(self):
"clean up the id of this object"
if 'name' in self.__dict__:
if self.name == 'id':
self.name == 'showId'
if not self.getId():
self.id = self.name
if self.getId() == 'id':
self.id = 'showId'
cleanupId = utility.upgradeLimit(cleanupId, 141)
security.declarePrivate('cleanupType')
def cleanupType(self):
"set type to None if we have it and it has no info"
if 'type' in self.__dict__ and self.type is None:
self.delObjects(['type'])
cleanupType = utility.upgradeLimit(cleanupType, 141)
security.declarePrivate('cleanupValues')
def cleanupValues(self):
"set the values to None if we have it and it has no info"
if 'values' in self.__dict__ and not self.values:
self.delObjects(['values'])
cleanupValues = utility.upgradeLimit(cleanupValues, 141)
class DataRecorder(base.Base):
"DataRecorder class"
meta_type = "DataRecorder"
security = ClassSecurityInfo()
fieldList = None
records = None
recordsLength = None
archive = None
archiveLength = None
allowArchive = 1
allowClear = 1
startTime = None
stopTime = None
orderHeaderPath = ''
catalogPath = ''
catalogArchivePath = ''
recordScriptPath = ''
recordRenderScriptPath = ''
fieldOrder = None #just to make it easier to remove from instances
HTMLDataFilter = HTMLDataFilter('HTMLDataFilter')
CSVDataFilter = CSVDataFilter('CSVDataFilter')
SeperatorDataFilter = SeperatorDataFilter('SeperatorDataFilter')
classConfig = {}
classConfig['allowArchive'] = {
'name': 'Allow Archiving?:',
'type': 'radio'
}
classConfig['allowClear'] = {'name': 'Allow Clearing?:', 'type': 'radio'}
classConfig['orderHeaderPath'] = {
'name': 'Path to Default Config Script',
'type': 'path'
}
classConfig['catalogPath'] = {'name': 'Path to Catalog', 'type': 'path'}
classConfig['catalogArchivePath'] = {
'name': 'Path to Archive Catalog',
'type': 'path'
}
classConfig['recordScriptPath'] = {
'name': 'Path to record modifier script',
'type': 'path'
}
classConfig['recordRenderScriptPath'] = {
'name': 'Path to record rendering script',
'type': 'path'
}
drawDict = base.Base.drawDict.copy()
drawDict['showRecords'] = 'showRecords'
drawDict['showArchive'] = 'showArchive'
drawDict['showFieldList'] = 'showFieldList'
drawDict['AdvancedEdit'] = 'advancedEdit'
updateReplaceList = ('catalogPath', 'catalogArchivePath',
'orderHeaderPath', 'allowArchive', 'allowClear')
security.declarePrivate('getCatalog')
def getCatalog(self, archive=None):
"get the current catalog if there is one"
if archive is not None:
path = self.getConfig('catalogArchivePath')
else:
path = self.getConfig('catalogPath')
if path:
obj = self.getCompoundDoc().restrictedTraverse(path, None)
if obj is not None and obj.meta_type == 'ZCatalog':
return obj
security.declarePrivate('getRecordScript')
def getRecordScript(self):
"get the record modifier script"
recordScriptPath = self.recordScriptPath
if recordScriptPath:
return self.restrictedTraverse(recordScriptPath, None)
def getRender(self, name):
"get the default recordRendering script"
if self.recordRenderScriptPath:
script = self.getCompoundDocContainer().restrictedTraverse(
self.recordRenderScriptPath, None)
if script is not None:
return script(name)
security.declareProtected('View management screens', 'showRecords')
def showRecords(self):
"show the records"
return self.showRecordsCommon(archive=0)
security.declareProtected('View management screens', 'showFieldList')
def showFieldList(self):
"show the fieldList as a view"
return self.unorderedList(self.fieldList or [])
security.declareProtected('View management screens', 'showArchive')
def showArchive(self):
"show the records"
return self.showRecordsCommon(archive=1)
security.declarePrivate('showRecordsCommon')
def showRecordsCommon(self, archive):
"common function for showing records/archives"
path = '_'.join(self.getPhysicalPath())
format = '''<div>%s<span id="%s_loadMenu_%s"></span></div>
<div id="%s_showDocument_%s"></div>
'''
return format % (self.getPrimaryMenu(archive=archive), path, archive,
path, archive)
security.declareProtected('View management screens', 'loadRecord')
def loadRecord(self, archive, selectedDocument, merge=0):
"load this record and return it for AJAX"
name, data = self.getSelectedDocument(
archive=archive, selectedDocument=selectedDocument, merge=merge)
doc = 'Can Not Load Document'
if name is not None and data is not None:
doc = Record(name=name,
data=data,
script=self.getRecordScript(),
parent=self).__of__(self).index_html()
return doc
security.declarePrivate('getMenu')
def getPrimaryMenu(self, archive=0):
"return the menu for these documents this is used in selectOne mode"
if archive:
records = self.archive
else:
records = self.records
if records is None:
return ''
temp = []
path = '_'.join(self.getPhysicalPath())
js = '''onchange="loadRecord(this, '#%s_loadMenu_%s','%s/getSecondaryMenu?archive:int=%s&start:int=')"''' % (
path, archive, self.absolute_url(), archive)
seq = [(idx * 100, DateTime.DateTime(i)) for idx, i in enumerate(
itertools.islice(records.keys(), None, None, 100))]
seq.insert(0, ('', 'Load Document'))
temp.append(
self.option_select(seq,
'selectedDocument',
dataType='list:ignore_empty',
events=js))
return ''.join(temp)
security.declareProtected('View management screens', 'getSecondaryMenu')
def getSecondaryMenu(self, start=0, archive=0):
"return the menu for these documents this is used in selectOne mode"
if archive:
records = self.archive
else:
records = self.records
if records is None:
return ''
temp = []
path = '_'.join(self.getPhysicalPath())
js = '''onchange="loadRecord(this, '#%s_showDocument_%s','%s/loadRecord?archive:int=%s&selectedDocument=')"''' % (
path, archive, self.absolute_url(), archive)
seq = [(repr(i), DateTime.DateTime(i))
for i in itertools.islice(records.keys(), start, start + 100)]
seq.insert(0, ('', 'Load Document'))
temp.append(
self.option_select(seq,
'selectedDocument',
dataType='list:ignore_empty',
events=js))
return ''.join(temp)
security.declarePrivate('getSelectedDocument')
def getSelectedDocument(self, archive=0, selectedDocument=None, merge=0):
"get the currently selected document"
if merge:
records = BTrees.OOBTree.OOBTree()
if self.records is not None:
records.update(self.records)
if self.archive is not None:
records.update(self.archive)
elif archive:
records = self.archive
else:
records = self.records
if selectedDocument is not None:
selectedDocument = float(selectedDocument)
try:
return selectedDocument, records[selectedDocument]
except KeyError:
pass
return None, None
security.declarePublic('__bobo_traverse__')
def __bobo_traverse__(self, REQUEST, name):
"getattr method"
try:
recordName = float(name)
except ValueError:
recordName = None
if self.records is not None and self.records.has_key(recordName):
"object has an object with name return that"
data = self.records[recordName]
doc = Record(name=name,
data=data,
script=self.getRecordScript(),
parent=self).__of__(self)
return doc
if self.archive is not None and self.archive.has_key(recordName):
"object has an object with name return that"
data = self.archive[recordName]
doc = Record(name=name,
data=data,
script=self.getRecordScript(),
parent=self).__of__(self)
return doc
guard = object()
item = getattr(self, name, guard)
if item is not guard:
return item
security.declareProtected('View management screens', "edit")
def edit(self, dateFormat='jQueryUIDate', *args, **kw):
"Inline edit short object"
format = """%s<div>%s%s%s</div><p>Find Items Between:%s and %s</p><p>%s</p>"""
lenArchive = self.archiveLength(
) if self.archiveLength is not None else 0
lenRecords = self.recordsLength(
) if self.recordsLength is not None else 0
rows = [('', 'Number of records'), ('Inbox', lenRecords),
('Archive', lenArchive)]
clear = ''
archive = ''
archiveClear = ''
if self.getConfig('allowClear'):
clear = self.create_button('clear', "Clear")
if self.getConfig('allowArchive'):
archive = self.create_button('archive', "Archive")
archiveClear = self.create_button('archiveClear',
"Archive & Clear")
if self.startTime is None:
self.addRegisteredObject('startTime', 'Date')
self.startTime.clearDateTime()
if self.stopTime is None:
self.addRegisteredObject('stopTime', 'Date')
self.stopTime.clearDateTime()
yearsBefore, yearsAfter = self.getYearsBeforeAndAfter()
return format % (self.createTable(rows), archiveClear, archive, clear,
self.startTime(mode='edit',
format=dateFormat,
yearsBefore=yearsBefore,
yearsAfter=yearsAfter),
self.stopTime(
mode='edit',
format=dateFormat,
yearsBefore=yearsBefore,
yearsAfter=yearsAfter), self.submitChanges())
security.declareProtected('View management screens', "advancedEdit")
def advancedEdit(self, *args, **kw):
"a better more advanced editing control"
url = self.absolute_url_path()
temp = []
temp.append(
com.javascript.document_ready([
com.javascript.tabs_init('dataRecorderTab'),
]))
tabs = (
(url + '/' + 'editStartTable', 'Start'),
(url + '/' + 'editRecordsTable', 'Inbox'),
(url + '/' + 'editArchivesTable', 'Archives'),
(url + '/' + 'editDownloadTable', 'Download'),
)
temp.append(com.javascript.tabs_html("dataRecorderTab", tabs))
return ''.join(temp)
def editStartTable(self):
"edit interface for the start tab of the new editing interface"
return self.edit()
def editDownloadTable(self):
"create the download table"
return '''<div>
<h2>Data Access</h2><br />
Your data is available three ways:<br />
(1) Left click on "unix", "windows" or "mac" to view as a 'comma separated values' (CSV) file.<br />
(2) Right click on"unix", "windows" or "mac" to download, then choose "Save Target as..." and name the file: [filename].CSV<br />
so you can "open" it in a spreadsheet or "import" it into a database.<br />
%s</div>
''' % self.CSVDataFilter(mode='view', tableHeader=1)
security.declareProtected('View management screens', "editRecordsTable")
def editRecordsTable(self):
"edit records table"
return self.editTable('recordsTable', 'recordsTable')
security.declareProtected('View management screens', "editArchivesTable")
def editArchivesTable(self):
"edit the archives table"
return self.editTable('archiveTable', 'archiveTable')
security.declarePrivate('editTable')
def editTable(self, tableId, tableDataFunc):
"create the edit interface for a DataTable"
headers = []
for name, displayName in self.HTMLDataFilter.getFieldOrder():
headers.append('<th>%s</th>' % displayName)
disableSort = ','.join((len(headers) - 1) * ['{ "bSortable": false }'])
temp = []
temp.append(
'''<script type="text/javascript" charset="utf-8">
$(document).ready(function() {
$('#%s').dataTable( {
"bProcessing": true,
"sDom": '<"top"iflp<"clear">>rt<"bottom"iflp<"clear">>',
"bServerSide": true,
"bJQueryUI": true,
"bFilter": false,"aoColumns": [
{ "bSortable": true, "sType": "Date" },
%s
],
"sAjaxSource": "%s/%s"
} );
} );
</script>''' %
(tableId, disableSort, self.absolute_url_path(), tableDataFunc))
temp.append('''<style>
#%s p {overflow-y: hidden; height:4em;}
</style>
''' % tableId)
temp.append(
'''<table cellpadding="0" cellspacing="0" border="0" class="display" id="%s"><thead><tr>'''
% tableId)
temp.extend(headers)
temp.append('''</tr></thead><tbody><tr>
<td colspan="%s" class="dataTables_empty">Loading data from server</td>
</tr></tbody><tfoot><tr>''' % len(headers))
temp.extend(headers)
temp.append('''</tr></tfoot></table>''')
return ''.join(temp)
security.declareProtected('View management screens', "recordsTable")
def recordsTable(self):
"get data for the records DataTable"
return self.getJSONDataTable(lengthRecords=self.recordsLength,
archive=0)
security.declareProtected('View management screens', "archiveTable")
def archiveTable(self):
"get data for the records DataTable"
return self.getJSONDataTable(lengthRecords=self.archiveLength,
archive=1)
security.declarePrivate('getJSONDataTAble')
def getJSONDataTable(self, lengthRecords, archive):
"get the information for DataTable in json format"
data = {}
sortOrder = self.REQUEST.form.get('sSortDir_0', 'asc')
start = int(self.REQUEST.form.get('iDisplayStart', 0))
length = int(self.REQUEST.form.get('iDisplayLength', 10))
data['iTotalRecords'] = lengthRecords(
) if lengthRecords is not None else 0
data['iTotalDisplayRecords'] = data['iTotalRecords']
data['sEcho'] = self.REQUEST.form.get('sEcho', 0)
if sortOrder == 'asc':
start = start
stop = start + length
elif sortOrder == 'desc':
stop = -start
start = -(start + length)
if not stop:
stop = data['iTotalRecords']
encoding = self.getEncoding()
clean = utility.cleanEncodingSeq
escape_html_seq = utility.escape_html_seq
format = u'''<p onclick="javascript:$.colorbox({href:'%s/loadRecord?archive:int=%s&selectedDocument=%s', innerWidth:'600px', maxWidth:'85%%', maxHeight:'85%%', innerHeight:'600px', onComplete:function(){$('#cboxLoadedContent').css('background-color', 'white');}});">%s</p>'''
baseUrl = self.absolute_url_path()
aaData = self.HTMLDataFilter.getDataRecords(
self.HTMLDataFilter.getFieldOrder(),
header=0,
archive=archive,
sliceStart=start,
sliceStop=stop,
keys=1)
aaData = ((key, clean(record)) for key, record in aaData)
aaData = ((key, escape_html_seq(record)) for key, record in aaData)
aaData = ([
format % (baseUrl, archive, repr(key), entry) for entry in record
] for key, record in aaData)
data['aaData'] = list(aaData)
if sortOrder == 'desc':
data['aaData'].reverse()
return json.dumps(data).encode(encoding, 'xmlcharrefreplace')
security.declarePrivate('getYearsBeforeAndAfter')
def getYearsBeforeAndAfter(self):
"find the number of years on either side of the entries we have in records and archives from now"
minRecord = None
maxRecord = None
minArchive = None
maxArchive = None
if self.records is not None:
minRecord = DateTime.DateTime(self.records.minKey())
maxRecord = DateTime.DateTime(self.records.maxKey())
if self.archive is not None:
minArchive = DateTime.DateTime(self.archive.minKey())
maxArchive = DateTime.DateTime(self.archive.maxKey())
nowYear = DateTime.DateTime().year()
#need to make sure the items are not None
minRecordYear = minRecord.year() if minRecord is not None else nowYear
maxRecordYear = maxRecord.year() if maxRecord is not None else nowYear
minArchiveYear = minArchive.year(
) if minArchive is not None else nowYear
maxArchiveYear = maxArchive.year(
) if maxArchive is not None else nowYear
minYear = max((nowYear - min(minRecordYear, minArchiveYear)), 1)
maxYear = max((max(maxRecordYear, maxArchiveYear) - nowYear), 1)
return minYear, maxYear
security.declarePrivate('configAddition')
def configAddition(self):
"addendum to the default config screen"
add = self.create_button('addRecords', "Add All Records To Catalog")
addArchive = self.create_button('addRecordsArchive',
"Add All Archive Records To Catalog")
return '<p>%s</p><p>%s</p>' % (add, addArchive)
security.declarePrivate('processRecorderChanges')
def processRecorderChanges(self, form):
"process the recorder changes"
if self.getConfig('allowClear') and form.pop('clear', None):
self.clearRecords()
if form.pop('addRecords', None):
self.addRecordsToCatalog()
if form.pop('addRecordsArchive', None):
self.addRecordsToCatalogArchive()
elif self.getConfig('allowArchive') and form.pop('archive', None):
self.addRecordsToArchive()
elif self.getConfig('allowArchive') and form.pop('archiveClear', None):
self.addRecordsToArchive()
self.clearRecords()
security.declarePrivate('addRecordsToArchive')
def addRecordsToArchive(self):
"add the current records to the archive"
if self.records is not None:
self.addMainRecordsToCatalogArchive()
if self.archive is None:
self.setObject('archive', BTrees.OOBTree.OOBTree())
if self.archiveLength is None:
self.setObject('archiveLength', BTrees.Length.Length())
#have to do this as a set of seperation operations
#so I know which are actually being copied over to change the length
archive = self.archive
change = self.archiveLength.change
for key, value in self.records.items():
if key not in archive:
archive[key] = persistent.mapping.PersistentMapping(value)
change(1)
security.declarePrivate('clearRecords')
def clearRecords(self):
"clear the current records object and the catalog entries for it"
if self.records is not None:
catalog = self.getCatalog()
if catalog is not None:
uncatalog_object = catalog.uncatalog_object
docPath = self.getPath()
for key in self.records.keys():
path = '/'.join([docPath, repr(key)])
uncatalog_object(path)
self.setObject('records', None)
self.setObject('recordsLength', None)
security.declarePrivate('addRecordsToCatalog')
def addRecordsToCatalog(self):
"add the current records to the catalog"
self.addRecordsToCatalogShared(records=self.records)
security.declarePrivate('addRecordsToCatalogArchive')
def addRecordsToCatalogArchive(self):
"add the current records to the catalog"
self.addRecordsToCatalogShared(archive=1, records=self.archive)
security.declarePrivate('addMainRecordsToCatalogArchive')
def addMainRecordsToCatalogArchive(self):
"add the current records to the catalog"
self.addRecordsToCatalogShared(archive=1, records=self.records)
security.declarePrivate('addRecordsToCatalogShared')
def addRecordsToCatalogShared(self, archive=None, records=None):
"add the current records to the catalog"
catalog = self.getCatalog(archive)
if catalog is not None and records is not None:
catalog_object = catalog.catalog_object
docPath = self.getPath()
for key, value in records.items():
data = copy.deepcopy(value)
doc = Record(name=repr(key),
data=data,
script=self.getRecordScript(),
parent=self).__of__(self)
path = '/'.join([docPath, repr(key)])
catalog_object(doc, uid=path)
security.declarePrivate('before_manage_edit')
def before_manage_edit(self, form):
"process the edits"
self.processRecorderChanges(form)
security.declareProtected('View', 'view')
def view(self):
"Render page"
return self.HTMLDataFilter.view()
security.declarePrivate("getDataFilters")
def getDataFilters(self):
"Return a list of all available filters"
return (self.HTMLDataFilter, self.CSVDataFilter,
self.SeperatorDataFilter)
#security.declarePrivate('instance')
#instance = (('HTMLDataFilter', ('create', 'HTMLDataFilter')),
# ('CSVDataFilter', ('create', 'CSVDataFilter')),
# ('SeperatorDataFilter', ('create', 'SeperatorDataFilter')))
security.declareProtected('Python Record Addition', 'addDictObject')
def addDictObject(self, dict, entryTime=None):
"Add a dict like object and copy its contents into the records list update fileldMap also"
temp = copy.deepcopy(dict)
fieldList = self.fieldList
if fieldList is None:
fieldList = []
for key in dict:
if key not in fieldList:
fieldList.append(key)
if fieldList:
self.fieldList = fieldList
if temp:
if entryTime is None:
entryTime = time.time()
if self.records is None:
self.setObject('records', BTrees.OOBTree.OOBTree())
if self.recordsLength is None:
self.setObject('recordsLength', BTrees.Length.Length())
data = persistent.mapping.PersistentMapping(temp)
self.records[entryTime] = data
self.recordsLength.change(1)
catalog = self.getCatalog()
if catalog is not None:
data = temp
doc = Record(name=repr(entryTime),
data=data,
script=self.getRecordScript(),
parent=self).__of__(self)
path = '/'.join([self.getPath(), repr(entryTime)])
catalog.catalog_object(doc, uid=path)
security.declareProtected('Python Record Access', 'getListDict')
def getListDict(self,
start=None,
stop=None,
query=None,
archive=None,
keys=None):
"Return the list that has all the dicts in it for python script use only"
allowed = self.getAllowedRecords(query)
if archive is not None:
records = self.archive
else:
records = self.records
if records is not None:
if keys:
subTrans = com.db.subTransDeactivateKeyValue
else:
subTrans = com.db.subTransDeactivate
if allowed is None:
if keys:
seq = records.items(start, stop)
else:
seq = records.values(start, stop)
results = subTrans(seq, 100, self.getPhysicalRoot())
else:
if keys:
recordsGen = ((key, records[key])
for key in self.allowedKeys(
records, start, stop, allowed))
else:
recordsGen = (records[key] for key in self.allowedKeys(
records, start, stop, allowed))
results = subTrans(recordsGen, 100, self.getPhysicalRoot())
if keys:
return [(key, dict(record)) for key, record in results]
else:
return [dict(record) for record in results]
return []
security.declareProtected('Python Record Modification', 'addDataToRecords')
def addDataToRecords(self,
script,
start=None,
stop=None,
query=None,
archive=None):
"Return the list that has all the dicts in it for python script use only"
allowed = self.getAllowedRecords(query)
if archive is not None:
records = self.archive
else:
records = self.records
if records is not None:
if allowed is None:
for key, value in com.db.subTrans(records.items(start, stop),
100):
newData = script(value)
newData.update(value)
newData = persistent.mapping.PersistentMapping(newData)
records[key] = newData
else:
for key in com.db.subTrans(
self.allowedKeys(records, start, stop, allowed), 100):
data = records[key]
newData = script(data)
newData.update(data)
newData = persistent.mapping.PersistentMapping(newData)
records[key] = newData
return []
security.declarePrivate("getAllowedRecords")
def getAllowedRecords(self, query):
"get the allowed records based on this query"
if query is not None:
catalog = self.getCatalog()
if catalog is not None:
return BTrees.OOBTree.OOTreeSet(
float(record.record_id) for record in catalog(query))
security.declarePrivate("allowedKeys")
def allowedKeys(self, records, start, stop, allowed):
"return the allowed keys"
if start is not None or stop is not None:
keyRange = BTrees.OOBTree.OOTreeSet(
records.keys(min=start, max=stop))
return BTrees.OOBTree.intersection(keyRange, allowed)
else:
return BTrees.OOBTree.intersection(records, allowed)
security.declareProtected('Python Record Access', 'getFieldList')
def getFieldList(self):
"Return the field list for python script use only"
if self.fieldList is not None:
return copy.copy(self.fieldList)
return []
security.declarePrivate("PrincipiaSearchSource")
def PrincipiaSearchSource(self):
"This is the basic search function"
return ''
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.changeListDictDataRecorder()
self.changeListDictDataRecorderArchive()
self.removeNotUsed()
self.removeNotNeededFilters()
self.createBTreeLength()
self.convertDictToPersistentMapping()
security.declarePrivate('changeListDictDataRecorder')
def changeListDictDataRecorder(self):
"Change the list to a dict in the DataRecorder"
if isinstance(self.records, types.ListType):
temp = BTrees.OOBTree.OOBTree()
for i in self.records:
temp[time.time()] = i
self.setObject('records', temp)
changeListDictDataRecorder = utility.upgradeLimit(
changeListDictDataRecorder, 141)
security.declarePrivate('changeListDictDataRecorderArchive')
def changeListDictDataRecorderArchive(self):
"Change the list to a dict in the DataRecorder archive item"
if isinstance(self.archive, types.ListType):
temp = BTrees.OOBTree.OOBTree()
for i in self.archive:
temp[time.time()] = i
self.setObject('archive', temp)
changeListDictDataRecorderArchive = utility.upgradeLimit(
changeListDictDataRecorderArchive, 141)
security.declarePrivate('removeNotUsed')
def removeNotUsed(self):
"remove fieldOrder and archive,fieldList,records if not being used"
toRemove = ['fieldOrder', 'fileNameBase']
if not self.fieldList:
toRemove.append('fieldList')
if self.archive is not None and not self.archive:
toRemove.append('archive')
if self.records is not None and not self.records:
toRemove.append('records')
self.delObjects(toRemove)
removeNotUsed = utility.upgradeLimit(removeNotUsed, 157)
security.declarePrivate('removeNotNeededFilters')
def removeNotNeededFilters(self):
"remove Filters that are not being used"
toRemove = []
if getattr(self.CSVDataFilter, 'visible', None) is None:
toRemove.append('CSVDataFilter')
if getattr(self.HTMLDataFilter, 'visible', None) is None:
toRemove.append('HTMLDataFilter')
if getattr(self.SeperatorDataFilter, 'visible', None) is None:
toRemove.append('SeperatorDataFilter')
self.delObjects(toRemove)
removeNotNeededFilters = utility.upgradeLimit(removeNotNeededFilters, 163)
security.declarePrivate('createBTreeLength')
def createBTreeLength(self):
"remove Filters that are not being used"
if self.records is not None:
length = BTrees.Length.Length()
length.set(len(self.records))
self.setObject('recordsLength', length)
if self.archive is not None:
length = BTrees.Length.Length()
length.set(len(self.archive))
self.setObject('archiveLength', length)
createBTreeLength = utility.upgradeLimit(createBTreeLength, 164)
security.declarePrivate('convertDictToPersistentMapping')
def convertDictToPersistentMapping(self):
"convert the dictionaries we have stored to persistent mapping so they can be deactivated"
if self.records is not None:
for key, value in com.db.subTrans(self.records.items(), 500):
self.records[key] = persistent.mapping.PersistentMapping(value)
if self.archive is not None:
for key, value in com.db.subTrans(self.archive.items(), 500):
self.archive[key] = persistent.mapping.PersistentMapping(value)
convertDictToPersistentMapping = utility.upgradeLimit(
convertDictToPersistentMapping, 167)
class ImageFilter(BasePicture):
"Image class"
security = ClassSecurityInfo()
meta_type = "ImageFilter"
image = None
data = None
location = ''
fileSize = ''
imagesrc = '' #obsolete
imagesrc_template = ''
thumbnail = None
url = ''
classConfig = BasePicture.classConfig.copy()
classConfig['location'] = {'name': 'Location of Image:', 'type': 'string'}
updateReplaceList = (
'format',
'color',
'location',
)
configurable = BasePicture.configurable + ('deletion', 'location')
attr_notified = set(['format', 'color', 'width', 'height'])
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit short object"
temp = []
if self.exists():
object = self.image
width, height = object.width, object.height
size = self.getFileSize()
if not size:
self.setFileSize()
size = self.getFileSize()
imageType = self.image.content_type
format = '<p>Preview: %s (%s px/%s px) %s %s </p>'
temp.append(format %
(self.small(), width, height, size, imageType))
temp.append(
'<p>These heights and widths will be used as closely as possible and keep aspect ratio.</p>'
)
width = self.editSingleConfig('width', format='%(form)s')
height = self.editSingleConfig('height', format='%(form)s')
temp.append(
'<p class="imageSize">Suggested Width:%s px Height:%s px</p>' %
(width, height))
return ''.join(temp)
security.declarePrivate('setFileSize')
def setFileSize(self):
"Store the file size of this object"
try:
fileSize = utility.fileSizeString(self.image.size)
self.setObject('fileSize', fileSize)
except AttributeError:
pass
security.declarePrivate('post_process_location')
def post_process_location(self, before, after):
"if the location is changed we need to ensure we unhook from the old picture"
#detach old picture
picture = self.getRemoteImage(before)
if picture is not None:
picture.observerDetached(self)
#attach new picture
picture = self.getRemoteImage(after)
if picture is not None:
picture.observerAttached(self)
self.observerUpdate(picture)
security.declarePrivate('after_manage_edit')
def after_manage_edit(self, dict):
"cache some information after this object has been modified"
if self.hasBeenModified() and not self.getConfig('scriptChangePath'):
self.regenImages()
security.declarePrivate('getRemoteImage')
def getRemoteImage(self, location=None):
"Get the remote image"
location = location if location is not None else self.getConfig(
'location')
return self.getRemoteObject(location, 'Picture')
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"This is the basic search function"
return ''
security.declarePrivate('observerUpdate')
def observerUpdate(self, pic):
"Process what you were observing"
self.regenImages(pic)
security.declareProtected('Change CompoundDoc', 'regenImages')
def regenImages(self, pic=None):
"regenerate the image and thumbnail"
#this handles the case where we can't find the remote object we should be attached to
remote = self.getRemoteImage()
if remote is None and self.getConfig('location'):
self.clear()
#this is the normal case
pic = pic if pic is not None else self.getRemoteImage()
if pic is not None and pic.exists():
if 'UpdateCacheOnly' in self.REQUEST.other:
self.updateImageSrcCache(remote=pic)
else:
self.generateImage(pic)
else:
self.clear()
security.declareProtected('Change CompoundDoc', 'clear')
def clear(self):
"clear this image"
self.delObjects(
['image', 'thumbnail', 'fileSize', 'imagesrc_template'])
security.declareProtected('Change CompoundDoc', 'resaveExistingImage')
def resaveExistingImage(self):
"reisze existing images"
if self.exists():
filename, remove_after = utility.createTempFile(self.image.data)
content_type = magicfile.magic(filename)
if content_type.startswith('image'):
temp_file, x, y = utility.resaveExistingImage(filename)
beforeSize = utility.fileSizeToInt(self.getFileSize())
if temp_file is not None and os.stat(
temp_file.name)[stat.ST_SIZE] < beforeSize:
self.image.manage_upload(temp_file)
self.image.width = x
self.image.height = y
#have to redo the content_type after we modify the image in case it has changed
content_type = magicfile.magic(temp_file.name)
temp_file.close()
self.setFileSize()
self.image.content_type = content_type
utility.removeTempFile(filename, remove_after)
security.declarePrivate('generateImage')
def generateImage(self, pic):
"generate an image and thumbnail based on this data"
filename, remove_after = utility.createTempFile(pic.data.data)
content_type = magicfile.magic(filename)
if content_type.startswith('image'):
self.genImage(filename)
self.updateImageSrcCache(pic)
self.makeThumbnail(filename)
utility.removeTempFile(filename, remove_after)
security.declarePrivate('updateImageSrcCache')
def updateImageSrcCache(self, remote=None):
"update the imagesrc cache string"
if self.exists():
decode = {}
decode['height'] = self.image.height
decode['width'] = self.image.width
remote = remote if remote is not None else self.getRemoteImage()
if remote is None:
alt = ''
tags = ''
else:
alt = remote.alt
tags = remote.tags
self.setObject('url', remote.url)
if com.detection.no_dtml(alt):
decode['alt'] = self.convert(alt)
else:
decode['alt'] = alt
decode['tags'] = tags
self.setObject('imagesrc_template',
image_template.safe_substitute(decode))
security.declarePrivate('genImage')
def genImage(self, filename):
"generate this image"
image = PIL.Image.open(filename)
if image.mode != self.getConfig('color'):
image = image.convert(self.getConfig('color'))
crop_left = self.getConfig('crop_left')
crop_upper = self.getConfig('crop_upper')
crop_right = self.getConfig('crop_right')
crop_lower = self.getConfig('crop_lower')
if crop_right and crop_lower:
image = image.crop((crop_left, crop_upper, crop_right, crop_lower))
(x, y) = image.size
if x > self.width:
y = y * self.width / x
x = self.width
if y > self.height:
x = x * self.height / y
y = self.height
if x == 0:
x = 1
if y == 0:
y = 1
image = image.resize((x, y))
tempFile = utility.saveImage(image, self.getConfig('format'))
if not self.image:
self.manage_addProduct['Image'].manage_addImage(
'image', tempFile, 'image')
else:
self.image.manage_upload(tempFile)
self.image.width = int(x)
self.image.height = int(y)
self.setFileSize()
security.declareProtected('View', 'view')
def view(self,
urlCallable=None,
parent=None,
additionalAttributes='',
drawHref=1,
url_data=None):
"Render page"
#parent = parent if parent is not None else self.getRemoteImage()
parent = parent if parent is not None else self.getCompoundDoc()
if self.exists():
decode = {}
decode['url'] = self.absolute_url_path_extension()
decode['additionalAttributes'] = additionalAttributes
if not self.imagesrc_template:
self.REQUEST.other['okayToRunNotification'] = 0
self.updateImageSrcCache()
self.delObjects(['imagesrc'])
image = Template(self.imagesrc_template).safe_substitute(decode)
url_data = url_data if url_data is not None else self.url
if drawHref and url_data:
href = com.html.generate_url(url_data,
parent,
self.REQUEST,
url_callable=urlCallable)
if href is not None:
image = '<a href="%s">%s</a>' % (href, image)
return image
return ''
security.declareProtected("Access contents information", 'exists')
def exists(self):
"Check if object has data in it"
try:
#just seeing if that image exists
self.image.image
return True
except AttributeError:
return False
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.save_pic_url()
security.declarePrivate('save_pic_url')
def save_pic_url(self):
"put the picture url in the imagefilter so we don't have to load a picture to draw an imagefilter"
if self.scriptChangePath: #if we have a notification script the only way we can update our data is to run it
self.REQUEST.other['UpdateCacheOnly'] = 1
self.runChangeNotificationScript()
del self.REQUEST.other['UpdateCacheOnly']
else:
self.updateImageSrcCache()
self.delObjects(['imagesrc'])
save_pic_url = utility.upgradeLimit(save_pic_url, 176)
class ContainerCompoundController(ObjectCompoundController):
"uses a container to give access to a view of many compounddocs"
meta_type = "ContainerCompoundController"
security = ClassSecurityInfo()
prepend = ''
randomId = 0
cdocName = ""
folderSwap = 0
allowAddRemove = 1
autoNumber = 1
sorton = ''
cdocIsContainer = 0
enableCutCopyPaste = 0
enableShowOne = 0
alternateDropDownAttributeName = ''
folderType = 'Folder'
drawControls = 1
dropDownPath = ''
autoType = ''
cdocAutoAddTypes = ('timestamp', 'counter')
folderTypes = (('Folder', 'Default Folder'), ('BTree', 'BTreeFolder2'))
classConfig = {}
classConfig['autoNumber'] = {
'name': 'Number the items on the page?',
'type': 'radio'
}
classConfig['cdocName'] = {
'name': 'Name of CompoundDoc if folder Swap is set:',
'type': 'string'
}
classConfig['folderSwap'] = {
'name': 'Swap CompoundDoc name for Folder Name:',
'type': 'radio'
}
classConfig['allowAddRemove'] = {
'name': 'Allow Documents to be added and removed?:',
'type': 'radio'
}
classConfig['prepend'] = {'name': 'Prepend Name:', 'type': 'string'}
classConfig['sorton'] = {'name': 'Sort on attribute:', 'type': 'string'}
classConfig['cdocIsContainer'] = {
'name':
'Make this cdoc the container instead of its containing folder?:',
'type': 'radio'
}
classConfig['enableCutCopyPaste'] = {
'name': 'Enable Cut/Copy/Paste support?:',
'type': 'radio'
}
classConfig['enableShowOne'] = {
'name': 'Show only one document at a time:',
'type': 'radio'
}
classConfig['alternateDropDownAttributeName'] = {
'name':
'Name of an attribute to use for alternate sorting in the drop down:',
'type': 'string'
}
classConfig['folderType'] = {
'name': 'Type of Folder to use',
'type': 'list',
'values': folderTypes
}
classConfig['drawControls'] = {
'name': 'Draw the individual document controls?:',
'type': 'radio'
}
classConfig['dropDownPath'] = {
'name': 'Path to the Drop Down Configuration:',
'type': 'path'
}
classConfig['autoType'] = {
'name': 'Auto Cdoc Naming',
'type': 'list',
'values': ('', ) + cdocAutoAddTypes
}
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"This is the basic search function"
return ''
security.declarePrivate('before_manage_edit')
def before_manage_edit(self, form):
"handle the copy support before we do other stuff"
if 'jump' in form:
del form['jump']
if 'selectedDocument' in form:
selected = form['selectedDocument']
for i in selected:
if i:
selected = i
break
else:
selected = ''
self.setSelectedDocument(selected)
copysupport = form.pop('copysupport', None)
if self.enableCutCopyPaste and copysupport is not None:
container = self.getCompoundDocContainer().restrictedTraverse(
form['tempEditFullPath'], None)
self.handleCopySupport(copysupport, container)
security.declarePrivate('after_manage_edit')
def after_manage_edit(self, form):
"Call this function after the editing has been processed so that additional things can be done like caching"
tempEditFullPath = form.get('tempEditFullPath', None)
folder = None
if tempEditFullPath is not None:
folder = self.getCompoundDocContainer().restrictedTraverse(
tempEditFullPath, None)
if folder is None:
folder = self.getEditFolder()
if folder is not None and self.allowAddRemove:
profile = self.editProfile
if not profile and 'profile' in form:
profile = form['profile']
if 'add' in form:
name = form.get('addName', '')
cdocName = folderSwap = None
if self.folderSwap and self.cdocName:
cdocName = self.cdocName
folderSwap = 1
autoType = self.getConfig('autoType')
if name or autoType:
cdoc = folder.manage_addProduct[
'CompoundDoc'].manage_addCompoundDoc(
name,
profile=profile,
redir=0,
prepend=self.prepend,
cdocName=cdocName,
folderCreate=folderSwap,
returnObject=1,
autoType=autoType)
if (form.get('singleMode', None)
or self.enableShowOne) and cdoc is not None:
self.setSelectedDocument(cdoc.getId())
if 'del' in form and 'delName' in form and form['delName']:
folder.manage_delObjects([
form['delName'],
])
def handleCopySupport(self, form, container):
"handle the copy and paste stuff"
if form.pop('cut', None) and 'ids' in form and self.allowAddRemove:
cp = container.manage_cutObjects(form['ids'])
resp = self.REQUEST.RESPONSE
resp.setCookie('__cp', cp, path='%s' % cookie_path(self.REQUEST))
self.REQUEST['__cp'] = cp
if form.pop('copy', None) and 'ids' in form:
cp = container.manage_copyObjects(form['ids'])
resp = self.REQUEST.RESPONSE
resp.setCookie('__cp', cp, path='%s' % cookie_path(self.REQUEST))
self.REQUEST['__cp'] = cp
if form.pop('paste',
None) and self.allowAddRemove and self.cb_dataValid(
): #part of CopySupport
container.manage_pasteObjects(self.REQUEST['__cp'])
security.declareProtected("Access contents information", 'getEditFolder')
def getEditFolder(self):
"get the folder this object is using for editing"
return self.getFolder('editFullPath')
security.declareProtected("Access contents information", 'getViewFolder')
def getViewFolder(self):
"get the folder this object is using for viewing"
return self.getFolder('viewFullPath')
security.declarePrivate('getFolder')
def getFolder(self, pathName):
"get the folder we are supposed to be using and create it if it does not exist"
path = getattr(self, pathName)
cdocContainer = self.getContainer()
folder = cdocContainer.restrictedTraverse(path, None)
if folder is None:
pathList = path.split('/')
self.setObject(
pathName, '/'.join(
utility.drawFolderPath(pathList, cdocContainer,
self.folderType)))
folder = cdocContainer.restrictedTraverse(path, None)
return folder
security.declarePrivate('getContainer')
def getContainer(self):
"return the continer we are using as an origin"
if self.cdocIsContainer:
return self.getCompoundDoc()
return self.getCompoundDocContainer()
security.declareProtected('View management screens', 'edit')
def edit(self,
dropDownScript=None,
loadFolder=1,
drawMenu=1,
container=None,
profile=None,
*args,
**kw):
"Inline edit view"
temp = []
folder = container or self.getFolder('editFullPath')
if folder is not None:
if loadFolder:
objects = self.getObjectsToWorkWith(folder, profile)
if dropDownScript or not self.dropDownPath:
self.sortObjects(objects, **kw)
else:
objects = tuple()
if self.allowAddRemove:
temp.extend(self.addRemoveDocument(folder, objects, profile))
if self.enableCutCopyPaste:
temp.extend(self.addCutCopyPasteControls())
temp.extend(
self.drawDocuments(objects, dropDownScript, drawMenu, folder,
profile, **kw))
return ''.join(temp)
def addCutCopyPasteControls(self):
"add the cut/copy/paste controls"
temp = []
if self.allowAddRemove:
temp.append(
self.create_button('cut', 'Cut', containers=('copysupport', )))
temp.append(
self.create_button('copy', 'Copy', containers=('copysupport', )))
if self.cb_dataValid(): #part of CopySupport
temp.append(
self.create_button('paste',
'Paste',
containers=('copysupport', )))
return temp
security.declarePrivate('drawDocuments')
def drawDocuments(self,
objects,
dropDownScript=None,
drawMenu=1,
container=None,
profile=None,
**kw):
"draw these documents"
drawOne = kw.get('selectOne', None)
if drawOne is None:
drawOne = self.enableShowOne
if drawOne:
return self.drawOne(objects, dropDownScript, container, profile,
**kw)
else:
return self.drawMany(objects, drawMenu, container, profile, **kw)
security.declarePrivate('drawOne')
def drawOne(self,
objects,
dropDownScript=None,
container=None,
profile=None,
**kw):
"draw only one object for editing"
temp = [
self.input_hidden('tempEditFullPath',
'/'.join(container.getPhysicalPath())),
self.input_hidden('singleMode', 1)
]
control = '<div>%s %s</div>'
showName = ''
selectBox = ''
mymode = kw.get('docMode', None) or self.editMode
view = kw.get('docRender', None) or self.editName
path = self.editObjectPath
profile = profile or self.editProfile
drawid = self.editId
drawControls = self.drawControls
cdoc = self.getCompoundDoc()
doc = self.getSelectedDocument(container)
temp.append('<div>%s</div>' %
self.getMenu(objects, dropDownScript, **kw))
if doc is not None and doc is not cdoc:
name = doc.getId()
if self.enableCutCopyPaste:
selectBox = self.check_box('ids',
name,
containers=('copysupport', ),
formType='list')
if drawid:
showName = name
if drawControls:
temp.append(control % (selectBox, showName))
data = self.embedRemoteObject(doc, path, mymode, view, profile, 0)
if data is not None:
temp.append(data)
else:
temp.append(
'<p>For some reason the document you selected could not be shown. Please report this problem.</p>'
)
return temp
security.declarePrivate('getSelectedDocument')
def getSelectedDocument(self, container=None):
"get the currently selected document"
name = self.REQUEST.form.get('selectedDocument', None)
if name is not None:
container = container or self.getEditFolder()
return getattr(container, name, None)
security.declarePrivate('drawMany')
def drawMany(self,
objects,
drawMenu=1,
container=None,
profile=None,
**kw):
"draw many of the compounddocs for editing"
temp = [
self.input_hidden('tempEditFullPath',
'/'.join(container.getPhysicalPath())),
self.input_hidden('singleMode', 0)
]
control = '<div id="%s">%s %s %s/%s %s</div>'
controlNoNumber = '<div id="%s">%s %s %s</div>'
showName = ''
numberOfDocuments = len(objects)
if drawMenu:
jsMenu = self.getJSMenu(objects)
else:
jsMenu = ''
selectBox = ''
mymode = kw.get('docMode', None) or self.editMode
view = kw.get('docRender', None) or self.editName
path = self.editObjectPath
profile = profile or self.editProfile
drawid = self.editId
drawControls = self.drawControls
cdoc = self.getCompoundDoc()
autoNumber = kw.get('autoNumber', None) or self.autoNumber
for index, (name, doc) in enumerate(objects):
if doc is not cdoc:
if self.enableCutCopyPaste:
selectBox = self.check_box('ids',
name,
containers=('copysupport', ),
formType='list')
if drawid:
showName = name
if drawControls:
if autoNumber:
temp.append(control %
(name, selectBox, showName, index + 1,
numberOfDocuments, jsMenu))
else:
temp.append(controlNoNumber %
(name, selectBox, showName, jsMenu))
temp.append(
self.embedRemoteObject(doc, path, mymode, view, profile,
0))
return temp
security.declarePrivate('addRemoveDocument')
def addRemoveDocument(self, folder, objects, profile=None):
"draw the add remove document interface"
temp = []
profile = profile or self.editProfile
objects = [''] + [name for name, i in objects]
temp.append(self.create_button('add', 'Add Document'))
if not self.getConfig('autoType'):
temp.append(self.input_text('addName', ''))
if not profile:
temp.append(
self.option_select(utility.getStoredProfileNames(), 'profile',
['Default']))
else:
temp.append(self.input_hidden('profile', profile))
doc = self.getSelectedDocument(folder)
selected = None
if doc is not None:
selected = [doc.getId()]
temp.append(self.option_select(objects, 'delName', selected=selected))
temp.append(self.create_button('del', 'Delete Document'))
return temp
security.declarePrivate('drawAlternateDropDown')
def drawAlternateDropDown(self, docs):
"draw the alternate drop down"
js = 'onchange="submit()"'
alternate = self.alternateDropDownAttributeName
if alternate:
seq = ((getattr(i, alternate, ''), name) for (name, i) in docs)
seq = ((method, name) for method, name in seq if callable(method))
seq = ((method(mode='view'), name) for method, name in seq)
seq = sorted(seq)
seq = ((name, method) for method, name in seq)
seq = list(seq)
if seq:
seq.insert(0, ('', 'Load Document'))
return self.option_select(seq,
'selectedDocument',
dataType='list:ignore_empty',
events=js)
return ''
security.declarePrivate('getJSMenu')
def getJSMenu(self, documents):
"return the javascript menu for these documents"
numberOfDocuments = len(documents)
format = '%s/%s %s'
seq = [(name, format % (index + 1, numberOfDocuments, name))
for index, (name, i) in enumerate(documents)]
seq.insert(0, ('jump', 'Jump To Document'))
temp = [
self.option_select(seq,
'jump',
selected=['jump'],
events='onchange="jumpTo(this)"')
]
alternate = self.alternateDropDownAttributeName
if alternate:
seq = ((getattr(i, alternate, ''), name)
for (name, i) in documents)
seq = ((method, name) for method, name in seq if callable(method))
seq = sorted((method(mode='view'), name) for method, name in seq)
seq = [(name, method) for method, name in seq]
if seq:
seq.insert(0, ('jump', 'Jump To Document'))
temp.append(
self.option_select(seq,
'jump',
selected=['jump'],
events='onchange="jumpTo(this)"'))
return ''.join(temp)
security.declarePrivate('getObjectsToWorkWith')
def getObjectsToWorkWith(self, folder, profile=None):
"get the objects we should work with from this folder"
objects = folder.objectItems('CompoundDoc')
profile = profile or self.editProfile
if profile:
objects = [(name, i) for name, i in objects
if i.profile == profile]
return list(objects)
security.declarePrivate('sortObjects')
def sortObjects(self, objects, **kw):
"sort these objects based on the sorton attribute"
sorton = kw.get('sorton', None) or self.sorton
sort = lambda o: None
if sorton:
def sort(o):
cdoc = o[1]
obj = getattr(cdoc, sorton, None)
if obj is not None:
return obj(mode='view')
objects.sort(key=sort)
security.declareProtected('View', 'view')
def view(self):
"Inline draw view"
temp = []
mymode = self.viewMode
view = self.viewName
path = self.viewObjectPath
profile = self.viewProfile
drawid = self.viewId
cdoc = self.getCompoundDoc()
folder = self.getFolder('viewFullPath')
if folder is not None:
for i in folder.objectValues('CompoundDoc'):
if i is not cdoc:
temp.append(
self.embedRemoteObject(i, path, mymode, view, profile,
drawid))
return ''.join(temp)
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.removeRandomId()
security.declarePrivate('makeDataASequence')
def removeRandomId(self):
"remove the randomId and stick timestamp in autotype if randomId is set"
if self.randomId:
self.setObject('autoType', 'timestamp')
self.delObjects([
'randomId',
])
removeRandomId = utility.upgradeLimit(removeRandomId, 160)
class DisplayFilter(base.Base):
"DisplayFilter apply this to an object to change how it outputs"
meta_type = "DisplayFilter"
security = ClassSecurityInfo()
overwrite = 1
code = ''
codeScript = None
codetype = 'PythonScript'
language = 'en'
wrapperHeader = 'return context.standard_html_header()'
wrapperHeaderScript = None
wrapperFooter = 'return context.standard_html_footer()'
wrapperFooterScript = None
wrapperHeaderDTML = '<dtml-var standard_html_header>'
wrapperFooterDTML = '<dtml-var standard_html_footer>'
flags = None
security.declarePrivate('instance')
instance = (('UserAgent', ('create', 'DisplayUserAgent')), )
security.declareProtected('View', 'view')
def view(self):
"Inline draw view"
if self.codetype == 'DTML':
return self.getCompoundDoc().gen_html(self.code)
elif self.codetype == 'Static':
return self.code
elif self.codetype == 'PythonScript':
return self.codeScript.__of__(self.getCompoundDoc())()
return ''
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit view"
temp = []
temp.append('''<script type="text/javascript">
$(function() {
$("#tabsMode").tabs({ cache: false , ajaxOptions: { cache: false }});
});
</script>
''')
temp.append('<div id="tabsMode"><ul>')
url = self.absolute_url_path()
temp.append('<li><a href="%s/%s">%s</a></li>' %
(url, 'editCode', 'Code'))
temp.append('<li><a href="%s/%s">%s</a></li>' %
(url, 'editSettings', 'Settings'))
temp.append('<li><a href="%s/%s">%s</a></li>' %
(url, 'editObjects', 'Objects'))
temp.append('</ul></div>')
temp.append(self.submitChanges())
return ''.join(temp)
security.declareProtected('View management screens', 'editObjects')
def editObjects(self):
"return a table of object listings with id and meta_type sorted by id"
self.REQUEST.RESPONSE.setHeader(
'Content-Type', 'text/html; charset=%s' % self.getEncoding())
temp = []
temp.append('<div>')
items = self.getCompoundDoc().objectItems()
table = sorted((key, value.meta_type) for key, value in items)
temp.append(self.createTable(table))
temp.append('</div>')
return ''.join(temp)
security.declareProtected('View management screens', 'editCode')
def editCode(self):
"draw the code edit interface"
self.REQUEST.RESPONSE.setHeader(
'Content-Type', 'text/html; charset=%s' % self.getEncoding())
temp = []
temp.append('<div>')
if self.codetype == 'PythonScript' and self.codeScript:
temp.append(self.drawScriptErrorsAndWarnings(self.codeScript))
temp.append(self.text_area('code', self.code))
temp.append('</div>')
return ''.join(temp)
security.declareProtected('View management screens', 'editSettings')
def editSettings(self):
"draw the settings edit interface"
self.REQUEST.RESPONSE.setHeader(
'Content-Type', 'text/html; charset=%s' % self.getEncoding())
temp = []
temp.append('<div>')
temp.append("<p>Type is :</p>%s\n" % self.option_select(
self.getAllowedTypes(), 'codetype', [self.codetype]))
temp.append("<p>Language is :</p>%s\n" % self.option_select(
UserAgent.getAllowedLanguages, 'language', [self.language]))
if self.codetype == 'PythonScript' and self.wrapperHeaderScript:
temp.append(
self.drawScriptErrorsAndWarnings(self.wrapperHeaderScript))
temp.append('<p>Header:</p>%s' %
self.input_text('wrapperHeader', self.wrapperHeader))
if self.codetype == 'PythonScript' and self.wrapperFooterScript:
temp.append(
self.drawScriptErrorsAndWarnings(self.wrapperFooterScript))
temp.append('<p>Footer:</p>%s' %
self.input_text('wrapperFooter', self.wrapperFooter))
temp.append(self.UserAgent.edit())
temp.append('</div>')
return ''.join(temp)
def drawScriptErrorsAndWarnings(self, script):
"draw the script errors and warnings for this script"
temp = []
if script.errors:
temp.append(
'<p>Errors Found</p><pre class="scriptErrors">%s</pre>' %
cgi.escape('\n'.join(script.errors), 1))
if script.warnings:
temp.append(
'<p>Warnings Found</p><pre class="scriptWarnings">%s</pre>' %
cgi.escape('\n'.join(script.warnings), 1))
return ''.join(temp)
security.declarePrivate('after_manage_edit')
def after_manage_edit(self, form):
"recompile the python script if we have one"
if self.codetype == 'PythonScript':
for i in ('code', 'wrapperHeader', 'wrapperFooter'):
self.recompileScript(i)
security.declarePrivate('recompileScript')
def recompileScript(self, baseName):
"recompile python script"
scriptName = '%sScript' % baseName
pyscript = getattr(self, scriptName, None)
if pyscript is None:
pyscript = PythonScript(scriptName)
self.setObject(scriptName, pyscript)
pyscript.ZPythonScript_edit('', getattr(self, baseName))
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"Return what can be search which is nothing"
return ''
security.declarePrivate("getAllowed")
def getAllowedTypes(self):
"Return the allowed types as a tuple"
return ('DTML', 'PythonScript', 'Static')
security.declarePrivate('willRender')
def willRender(self):
"return true if I can render given the current client language etc"
Agent = self.getUserAgent()
return [
Agent.checkClientCompat(self.UserAgent.getClients(),
self.UserAgent.operatingSystems),
Agent.checkClientLanguage(self.language), self
]
security.declarePrivate('getWrappers')
def getWrappers(self):
"return the header and footer wrapper"
if self.codetype == 'PythonScript':
return (self.wrapperHeaderScript(), self.wrapperFooterScript())
gen_html = self.getCompoundDoc().gen_html
return (gen_html(self.wrapperHeader), gen_html(self.wrapperFooter))
security.declarePrivate('getClients')
def getClients(self):
"Get the clients of this object"
return getattr(aq_base(self), 'clients', None)
security.declarePrivate('setClients')
def setClients(self, clients):
"set the clients for this object"
self.setObject('clients', clients)
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.upgraderChangeUserAgentTuple()
self.upgraderChangeTupleTreeAgent()
self.upgraderFixAgents()
self.removeOldVars()
self.cleanupPythonScript()
self.oldDTMLDefaultWrappers()
self.correctIdOfScripts()
security.declarePrivate('removeOldVars')
def removeOldVars(self):
"remove some old vars that are no longer needed"
if 'optional' in self.__dict__:
self.delObjects(['optional'])
if 'required' in self.__dict__:
self.delObjects(['required'])
removeOldVars = utility.upgradeLimit(removeOldVars, 141)
security.declarePrivate('cleanupPythonScript')
def cleanupPythonScript(self):
"cleanup the python script objects"
if self.codetype == 'PythonScript':
self.delObjects(['script', 'footerScript', 'headerScript'])
if not self.objectIds('Script (Python)'):
for i in ('code', 'wrapperHeader', 'wrapperFooter'):
self.recompileScript(i)
cleanupPythonScript = utility.upgradeLimit(cleanupPythonScript, 141)
security.declarePrivate('correctIdOfScripts')
def correctIdOfScripts(self):
"Fix the id of scripts so they don't just say script"
for name, script in self.objectItems('Script (Python)'):
if script.id != name:
script.id = name
correctIdOfScripts = utility.upgradeLimit(correctIdOfScripts, 141)
security.declarePrivate('oldDTMLDefaultWrappers')
def oldDTMLDefaultWrappers(self):
"add a dtml wrapper as default for an old dtml display filter"
if self.codetype == 'DTML':
wrapperHeader = self.__dict__.get('wrapperHeader', None)
if wrapperHeader is None:
self.setObject('wrapperHeader', self.wrapperHeaderDTML)
wrapperFooter = self.__dict__.get('wrapperFooter', None)
if wrapperFooter is None:
self.setObject('wrapperFooter', self.wrapperFooterDTML)
oldDTMLDefaultWrappers = utility.upgradeLimit(oldDTMLDefaultWrappers, 141)
security.declarePrivate('upgraderChangeUserAgentTuple')
def upgraderChangeUserAgentTuple(self, clients=None):
"Change the user agent to the newer tuple format for detection"
if not clients:
clients = self.getClients()
lookup = {
'Konqueror/2.2': ('Mozilla/5', 'Konqueror', '2', '2'),
'Konqueror': ('Mozilla/5', 'Konqueror', '', ''),
'MSIE': ('Mozilla/4', 'MSIE', '', ''),
'MSIE 6': ('Mozilla/4', 'MSIE', '6', ''),
'MSIE 6.0': ('Mozilla/4', 'MSIE', '6', '0'),
'MSIE 5': ('Mozilla/4', 'MSIE', '5', ''),
'MSIE 4': ('Mozilla/4', 'MSIE', '4', ''),
'MSIE 3': ('Mozilla/3', 'MSIE', '3', ''),
'MSIE 2': ('Mozilla/2', 'MSIE', '2', ''),
'MSIE 5.5': ('Mozilla/4', 'MSIE', '5', '5'),
'MSIE 5.0': ('Mozilla/4', 'MSIE', '5', '0'),
'Opera': ('', 'Opera', '', ''),
'Opera/6': ('', 'Opera', '6', ''),
'Opera/6.0': ('', 'Opera', '6', '0'),
'Opera/5': ('', 'Opera', '5', ''),
'Opera/5.0': ('', 'Opera', '5', '0')
}
if operator.isSequenceType(clients):
list = [lookup[i] for i in clients if i in lookup]
if len(list):
self.setClients(tuple(list))
upgraderChangeUserAgentTuple = utility.upgradeLimit(
upgraderChangeUserAgentTuple, 141)
security.declarePrivate('upgraderChangeTupleTreeAgent')
def upgraderChangeTupleTreeAgent(self):
"Change the tuple structure to a tree"
clients = self.getClients()
if operator.isSequenceType(clients):
self.setClients(utility.mergeSequenceTree(clients))
upgraderChangeTupleTreeAgent = utility.upgradeLimit(
upgraderChangeTupleTreeAgent, 141)
security.declarePrivate('upgraderFixAgents')
def upgraderFixAgents(self):
"Fix the useragent detection vars to use the newer DisplayUserAgent object"
if self.hasObject('clients') and self.clients is not None:
self.gen_vars()
mapping = self.UserAgent.clientSetMapping()
for key, value in mapping.items():
if key and value:
mapping[key] = getattr(self.UserAgent, value)()
else:
del mapping[key]
for setname, clients in mapping.items():
if self.clients == clients:
self.UserAgent.setused = setname
self.delObjects(['clients'])
break
if self.hasObject('clients') and self.clients is not None:
self.UserAgent.setClients(self.clients)
self.delObjects(['clients'])
upgraderFixAgents = utility.upgradeLimit(upgraderFixAgents, 141)
class BaseTab(Base):
"Basic item to make multi tabbed interfaces"
meta_type = "BaseTab"
security = ClassSecurityInfo()
overwrite = 1
displayType = 'edit'
tabMapping = None
tabOrder = None
renderer = 'Horizontal'
columns = 0
configScript = ''
active = 1
classConfig = {}
classConfig['renderer'] = {
'name': 'Rendering Output',
'type': 'list',
'values': NestedListURL.lookup.keys()
}
classConfig['configScript'] = {
'name': 'Path to script configuration for tabs',
'type': 'path'
}
classConfig['active'] = {
'name': 'Activate the tab manager?',
'type': 'radio'
}
configurable = ('configScript', 'active', 'renderer', 'tabOrder',
'tabMapping')
security.declarePrivate('getTabMapping')
def getTabMapping(self, name):
"get the tabMapping from this name"
if self.tabMapping is not None:
return self.tabMapping.get(name, name)
return name
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit view"
temp = []
typeformat = '<div>Id: %s Display:%s</div>'
cdoc = self.getCompoundDoc()
displays = ['']
if cdoc.DisplayManager is not None:
displays.extend(cdoc.DisplayManager.displayUsage(self.displayType))
if cdoc.displayMap is not None:
displays.extend(cdoc.displayMap.keys())
tabOrder = self.tabOrder
if tabOrder is None:
tabOrder = []
neededEntries = len(tabOrder) + 1
temp.append(self.editSingleConfig('renderer'))
temp.append(NestedListURL.editRenderer(self.renderer, self))
tabMapping = self.tabMapping
if tabMapping is None:
tabMapping = {}
for index in xrange(neededEntries):
try:
nameValue = tabOrder[index]
displayValue = tabMapping[nameValue]
except (IndexError, KeyError):
nameValue = ''
displayValue = ''
temp.append(
typeformat %
(self.input_text(
'name', nameValue, containers=('tabMapping', str(index))),
self.option_select(displays,
'display', [displayValue],
containers=('tabMapping', str(index)))))
return ''.join(temp)
security.declarePrivate('before_manage_edit')
def before_manage_edit(self, dict):
"Process edits."
tabMapping = dict.pop('tabMapping', None)
if tabMapping is not None:
temp = {}
for i, j in tabMapping.items():
temp[int(i)] = j
temp = ((dictionary['name'].strip(), dictionary['display'].strip())
for index, dictionary in sorted(temp.iteritems()))
cleaned = [(name, display) for name, display in temp
if name and display]
if len(cleaned):
tabOrder = [name for name, value in cleaned]
self.setObject('tabOrder', tabOrder)
temp = {}
for name, display in cleaned:
temp[name] = display
self.setObject('tabMapping', temp)
else:
self.delObjects(('tabOrder', 'tabMapping'))
security.declarePrivate('getTabOrder')
def getTabOrder(self, doc=None, tabScript=None):
"get the tabOrder list structure"
doc = doc or self.getCompoundDoc()
query = utility.getQueryDict(
self.REQUEST.environ.get('QUERY_STRING', ''))
configScript = tabScript or self.getConfigScript()
if configScript is not None:
return self.correctScriptTabOrder(configScript(doc), query)
tabOrder = self.getConfig('tabOrder')
if tabOrder is not None:
return [(name, name, '', {}, query) for name in tabOrder]
return []
security.declarePrivate('correctScriptTabOrder')
def correctScriptTabOrder(self, seq, query):
"correct the script tabOrder to account for the dictionary that can be used to pass in vars"
temp = []
for item in seq:
try:
url, link, cssClasses = item
queryDict = {}
except ValueError:
url, link, cssClasses, queryDict = item
temp.append([url, link, cssClasses, queryDict, query])
return temp
security.declarePrivate('getConfigScript')
def getConfigScript(self):
"return the config script object"
configScript = self.getConfig('configScript')
script = None
if configScript:
script = self.getCompoundDocContainer().restrictedTraverse(
configScript, None)
return script
security.declarePrivate('getTabActive')
def getTabActive(self):
"return True only if we are set as active and we have data"
return self.getConfig('active') and (self.getConfig('tabMapping')
is not None
or self.getConfig('configScript'))
security.declarePrivate('beforeProfileLoad')
def beforeProfileLoad(self):
"run this action before loading the object with profile information"
self.performUpdate()
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.fixTabOrder()
security.declarePrivate('fixTabOrder')
def fixTabOrder(self):
"fix the tabOrder object"
if not self.hasObject('tabOrder'):
if self.tabMapping is not None:
keys = sorted(self.tabMapping.keys())
else:
keys = None
self.setObject('tabOrder', keys)
fixTabOrder = utility.upgradeLimit(fixTabOrder, 141)
class SimpleEmbed(UserObject, mixremoteembed.MixRemoteEmbed):
"Base for all objects that embed remote objects"
meta_type = "SimpleEmbed"
security = ClassSecurityInfo()
overwrite = 1
path = ''
security.declareProtected('View', 'embedded')
def embedded(self):
"return the object"
item = getattr(self, 'embed', None)
if item is not None:
return item
if not self.path:
return None
item = self.restrictedTraverse(self.path, None)
if item is not None:
self.setObject('embed', aq_base(item))
return item
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"Return what can be search which is nothing"
return ''
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit view"
self.setDrawMode('edit')
item = self.embedded()
if item is not None and getattr(item, 'meta_type',
None) == 'CompoundDoc':
return item.__of__(self).gen_html(
item.render(mode='edit', name=self.editDisplayName))
else:
return ''
security.declareProtected('View', 'view')
def view(self):
"Inline draw view"
self.setDrawMode('view')
item = self.embedded()
if item is not None and getattr(item, 'meta_type',
None) == 'CompoundDoc':
return item.__of__(self).gen_html(
item.render(mode='view', name=self.viewDisplayName))
else:
return ''
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.removeDTMLAttributes()
security.declarePrivate('removeDTMLAttributes')
def removeDTMLAttributes(self):
"remove the DTML attributes"
self.delObjects(['editDTML', 'viewDTML'])
removeDTMLAttributes = utility.upgradeLimit(removeDTMLAttributes, 141)
security.declarePrivate('performUpgrade')
def performUpgrade(self):
"perform the upgrade on this object but do no descend to the children"
self.upgrader()
class CatalogManager(Selection, basemanager.BaseManager):
"CatalogManager manages all displays"
meta_type = "CatalogManager"
security = ClassSecurityInfo()
overwrite = 1
multipleSelect = 1
rowsVisible = 10
allowClear = 1
UserObject = 0
catalogScriptPath = ""
classConfig = {}
classConfig['catalogScriptPath'] = {
'name': 'Path to Catalog Script',
'type': 'path'
}
security.declarePrivate('getChoices')
def getChoices(self):
'get the available choices to select from'
for i in self.superValues('ZCatalog'):
name = i.getId()
if name != 'CDocUpgrader':
yield name
security.declarePrivate('event_data')
def event_data(self, data):
"unindex this object if the data is different then what we already have"
if self.data != data:
self.unindex_object()
security.declarePrivate('getSelectedItems')
def getSelectedItems(self):
"get the currently selected items"
return self
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.updateCatalogConfig()
security.declarePrivate('getCatalogs')
def getCatalogs(self, doc):
"get the catalog objects"
if self.catalogScriptPath:
return self.getCatalogsScript(doc)
cdoc = self.getCompoundDoc()
catalogs = (getattr(cdoc, name, None) for name in self if name)
return [catalog for catalog in catalogs if catalog is not None]
security.declarePrivate('getCatalogsScript')
def getCatalogsScript(self, doc):
"get the catalogs from the script"
path = self.catalogScriptPath
if path:
script = self.getCompoundDocContainer().restrictedTraverse(
path, None)
if script is not None:
return script(doc)
return []
security.declarePrivate('updateCatalogConfig')
def updateCatalogConfig(self):
"take the info we need from CatalogConfig objects and then remove them"
for item in self.objectValues('CatalogConfig'):
name = item.useCatalog
if name and name not in self:
self.append(name)
self.delObjects(self.objectIds('CatalogConfig'))
updateCatalogConfig = utility.upgradeLimit(updateCatalogConfig, 141)
class SimpleList(UserObject):
"SimpleList object"
security = ClassSecurityInfo()
meta_type = "SimpleList"
radioOptions = (('append', 'Add'), ('remove', 'Remove'), ('replace',
'Replace'))
entry = None
security.declareProtected('CompoundDoc: Modify SimpleList', 'addEntries')
def addEntries(self, items):
"add these items to our current list of items"
if self.entry is None:
self.replaceEntries(items)
for item in items:
if not self.entry.has_key(item):
self.entry.insert(item)
security.declareProtected('CompoundDoc: Modify SimpleList',
'removeEntries')
def removeEntries(self, items):
"removes these items from the current set of entries"
if self.entry is not None:
for item in items:
if self.entry.has_key(item):
self.entry.remove(item)
security.declareProtected('CompoundDoc: Modify SimpleList',
'replaceEntries')
def replaceEntries(self, items):
"replace all the entries with these ones"
self.entry = OOTreeSet()
for item in items:
self.entry.insert(item)
security.declareProtected('CompoundDoc: View SimpleList',
'drawViewWindows')
def drawViewWindows(self):
"draw the list of addresses in windows format"
return '\r\n'.join(self.getEntries())
security.declareProtected('CompoundDoc: View SimpleList', 'drawViewMac')
def drawViewMac(self):
"draw the list of addresses in mac format"
return '\r'.join(self.getEntries())
security.declareProtected('CompoundDoc: View SimpleList', 'drawViewUnix')
def drawViewUnix(self):
"draw the list of addresses in unix format"
return '\n'.join(self.getEntries())
radioLookup = {
'append': addEntries,
'remove': removeEntries,
'replace': replaceEntries
}
security.declareProtected('CompoundDoc: Add List Item', 'addEntry')
def addEntry(self, item):
"Add an entry to the list"
if self.entry is None:
self.entry = OOTreeSet()
self.entry.insert(item)
security.declareProtected('CompoundDoc: Del List Item', 'delEntry')
def delEntry(self, item):
"Remove an entry form the list"
if self.entry.has_key(item):
self.entry.remove(item)
if not len(self.entry):
self.entry = None
security.declareProtected('CompoundDoc: Has List Item', 'hasEntry')
def hasEntry(self, item):
"Do we have this item"
if self.entry is not None:
return self.entry.has_key(item)
security.declareProtected('CompoundDoc: Get List Items', 'getEntries')
def getEntries(self):
"Return all the entries as a list"
if self.entry is not None:
return self.entry.keys()
return OOTreeSet()
security.declareProtected('CompoundDoc: Get List Items', 'getTree')
def getTree(self):
"Return all the entries as the native format"
if self.entry is not None:
return self.entry
return OOTreeSet()
security.declareProtected('CompoundDoc: Clear List Items', 'clearEntries')
def clearEntries(self):
"Remove all the entries from the object"
self.entry = None
security.declarePrivate('before_manage_edit')
def before_manage_edit(self, dict):
"process the edits"
if 'editAdd' in dict and 'editAddName' in dict:
self.addEntries(dict['editAddName'])
if 'editDel' in dict and 'editDelName' in dict:
self.removeEntries(dict['editDelName'])
if 'editClear' in dict:
self.clearEntries()
data = dict.pop('data', None)
if data is not None:
temp = data.read().split()
self.radioLookup[dict['fileSettings']](self, temp)
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit short object"
temp = []
append = temp.append
append(self.text_area('editAddName', '', formType="tokens"))
append('<p>%s</p>' % self.create_button("editAdd", "Add Entries"))
append(self.text_area('editDelName', '', formType="tokens"))
append('<p>%s</p>' % self.create_button("editDel", "Delete Entries"))
append('<p>Upload File:')
append(self.input_file('data'))
temp.extend(
self.radio_list('fileSettings',
self.radioOptions,
selected='append'))
append('</p>')
append(self.create_button("editClear", "Clear All Entries"))
append('<p>View Email Addresses:')
path = self.absolute_url_path()
format = ' <a href="%s">%s</a> '
append(format % (os.path.join(path, 'drawViewWindows'), 'Windows'))
append(format % (os.path.join(path, 'drawViewUnix'), 'Unix'))
append(format % (os.path.join(path, 'drawViewMac'), 'Mac'))
append('</p>')
return ''.join(temp)
security.declareProtected('View', 'view')
def view(self):
"Inline draw view"
return self.unorderedList(self.getEntries())
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"This is the basic search function"
return ' '.join(self.getEntries())
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.convertListToOOTreeSet()
security.declarePrivate('convertListToOOTreeSet')
def convertListToOOTreeSet(self):
"conver the list object to an OOTreeSet"
if len(self.entry) and isinstance(self.entry, types.ListType):
temp = OOTreeSet()
for i in self.entry:
temp.insert(i)
self.setObject('entry', temp)
convertListToOOTreeSet = utility.upgradeLimit(convertListToOOTreeSet, 141)
class Selection(UserObject):
"Input text class"
security = ClassSecurityInfo()
meta_type = "Selection"
data = None
selection = None
scriptPath = ""
multipleSelect = 0
rowsVisible = 1
allowClear = 0
outputFormat = 'list'
dataType = 'string'
scriptChangePath = ''
outputValues = (('list', 'Drop Down List'),
('radioinline', 'Radio Box Inline'), ('radioblock',
'Radio Box Block'),
('checkinline', 'CheckBox Inline'), ('checkblock',
'CheckBox Block'))
dateTypes = ('string', 'int', 'float')
classConfig = {}
classConfig['scriptPath'] = {'name': 'Path to Script', 'type': 'path'}
classConfig['multipleSelect'] = {
'name': 'Enable Multiple Selection',
'type': 'radio'
}
classConfig['rowsVisible'] = {
'name': 'Number of Rows Visible for Selection',
'type': 'int'
}
classConfig['allowClear'] = {
'name': 'Enable the clear button',
'type': 'radio'
}
classConfig['outputFormat'] = {
'name': 'Output Format',
'type': 'list',
'values': outputValues
}
classConfig['dataType'] = {
'name': 'Type of Date Stored',
'type': 'list',
'values': dateTypes
}
classConfig['scriptChangePath'] = {
'name': 'Path to change notification script',
'type': 'path'
}
updateReplaceList = (
'scriptPath',
'multipleSelect',
'rowsVisible',
'allowClear',
'outputFormat',
'dataType',
)
configurable = (
'dataType',
'allowClear',
'outputFormat',
'multipleSelect',
'rowsVisible',
'scriptPath',
)
security.declarePrivate('validate_data')
def validate_data(self, value):
"validate this value for the new value for the data attribute and then return what is okay"
if isinstance(value, basestring):
value = [
value,
]
temp = []
allowed = set(self.getChoiceValues())
checker = validators.getChecker(self.getConfig('dataType'))
for i in value:
i = checker(i)
if i is not None and i in allowed:
temp.append(i)
if temp:
return temp
security.declarePrivate('post_process_dataType')
def post_process_dataType(self, before, after):
"if the dataType is changed we need to ensure that all items in data fall in this new data type"
self.revalidateData()
security.declarePrivate('revalidateData')
def revalidateData(self):
"revalidate this data object"
data = self.data
if data is not None:
self.setObject('data', self.validate_data(data))
security.declareProtected('View management screens', 'edit')
def edit(self, outputFormat=None, *args, **kw):
"Inline edit short object"
clear = ''
if self.getConfig('allowClear'):
clear = self.create_button('clear',
'Clear %s' % self.getId()) + '<br>'
return clear + self.getEditControl(outputFormat)
security.declarePrivate('getEditControl')
def getEditControl(self, outputFormat=None):
"get the edit control"
choices = self.getChoices()
data = self.data
if data is None:
data = []
outputFormat = outputFormat or self.getConfig('outputFormat')
if outputFormat == 'list':
return self.option_select(
choices,
'data',
data,
multiple=self.getConfig('multipleSelect'),
size=self.getConfig('rowsVisible'),
dataType='list')
if outputFormat == 'radioinline':
return self.radio_box_inline(choices, 'data', data)
if outputFormat == 'radioblock':
return self.radio_box_block(choices, 'data', data)
if outputFormat == 'checkinline':
return self.checkbox_inline(choices, 'data', data)
if outputFormat == 'checkblock':
return self.checkbox_block(choices, 'data', data)
return ''
security.declarePrivate('before_manage_edit')
def before_manage_edit(self, dict):
"process the edits"
clear = dict.pop('clear', None)
if clear is not None:
self.clear()
try:
del dict['data']
except KeyError:
pass
security.declareProtected("Access contents information", 'getChoices')
def getChoices(self):
'get the available choices to select from'
temp = []
scriptPath = self.getConfig('scriptPath')
if scriptPath:
script = self.getCompoundDocContainer().restrictedTraverse(
scriptPath, None)
if script is not None:
temp = self.changeCallingContext(script)()
return temp
security.declareProtected("Access contents information", 'getChoiceValues')
def getChoiceValues(self):
'get the available choices to select from'
for i in self.getChoices():
if isinstance(i, basestring):
yield i
else:
try:
yield i[0]
except (TypeError, ValueError):
yield i
security.declarePrivate('getSelectedItems')
def getSelectedItems(self):
"get the currently selected items"
data = self.data
if data is None:
if self.getConfig('multipleSelect'):
return []
else:
return ''
if self.getConfig('multipleSelect'):
return data
else:
return data[0]
security.declareProtected('View', 'view')
def view(self):
"Inline draw view"
return self.getSelectedItems()
#List behavior stuff
security.declareProtected("Access contents information", "__getitem__")
def __getitem__(self, i):
if self.data:
return self.data[i]
raise IndexError
security.declareProtected("Access contents information", "__getslice__")
def __getslice__(self, i, j):
i = max(i, 0)
j = max(j, 0)
for i in self.data[i:j]:
yield i
security.declareProtected("Access contents information", "__iter__")
def __iter__(self):
if self.data:
for i in self.data:
yield i
security.declareProtected("Access contents information", "__len__")
def __len__(self):
if self.data:
return len(self.data)
return 0
security.declareProtected('Change CompoundDoc', '__setitem__',
'__guarded_setitem__')
def __setitem__(self, i, item):
if self.data:
self.data[i] = item
self._p_changed = 1
__guarded_setitem__ = __setitem__
security.declareProtected('Change CompoundDoc', '__delitem__',
'__guarded_delitem__')
def __delitem__(self, i):
if self.data:
del self.data[i]
if not len(self.data):
self.data = None
self._p_changed = 1
__guarded_delitem__ = __delitem__
#For some reason through the web code can't call this method so disabling it
#security.declareProtected('Change CompoundDoc', '__setslice__')
#def __setslice__(self, i, j, other):
# i = max(i, 0); j = max(j, 0)
# if self.data:
# for index in range(i,j):
# self.data[index] = other[index]
#For some reason through the web code can't call this method so disabling it
#security.declareProtected('Change CompoundDoc', '__delslice__')
#def __delslice__(self, i, j):
# i = max(i, 0); j = max(j, 0)
# if self.data:
# items = self.data[i:j]
# del self.data[i:j]
# for i in items:
# self.deleteRegisteredObject(i.getId(), [])
# if not len(self.data):
# self.data=None
# self._p_changed = 1
security.declareProtected('Access contents information', '__contains__')
def __contains__(self, name):
if self.data:
return name in self.data
return False
security.declareProtected('Change CompoundDoc', 'append')
def append(self, item):
if not self.data:
self.data = []
self.data.append(item)
self._p_changed = 1
security.declareProtected('Change CompoundDoc', 'insert')
def insert(self, i, item):
if not self.data:
self.data = []
self.data.insert(i, item)
self._p_changed = 1
security.declareProtected('Change CompoundDoc', 'pop')
def pop(self, i=-1):
if self.data:
item = self[i]
del self[i]
return item
security.declareProtected('Change CompoundDoc', 'reverse')
def reverse(self):
if self.data:
self.data.reverse()
self._p_changed = 1
security.declareProtected('Change CompoundDoc', 'clear')
def clear(self):
self.setObject('data', None, runValidation=0)
security.declareProtected('Change CompoundDoc', 'store')
def store(self, items, runValidation=1):
self.setObject('data', items, runValidation)
#End list behavior stuff
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.makeDataASequence()
self.clearSelection()
self.removeScriptEnabled()
self.fixupData()
security.declarePrivate('makeDataASequence')
def makeDataASequence(self):
"turn data into a sequence if it is not one already"
data = self.data
if data is not None and isinstance(data, basestring):
self.data = [data]
makeDataASequence = utility.upgradeLimit(makeDataASequence, 141)
security.declarePrivate('clearSelection')
def clearSelection(self):
"clear the selection variable it is no longer used"
self.setObject('selection', None)
clearSelection = utility.upgradeLimit(clearSelection, 141)
security.declarePrivate('removeScriptEnabled')
def removeScriptEnabled(self):
"remove the scriptEnabled attribute since it is not needed anymore"
self.delObjects([
'scriptEnabled',
])
removeScriptEnabled = utility.upgradeLimit(removeScriptEnabled, 144)
security.declarePrivate('fixupData')
def fixupData(self):
"if the data attribute is a string turn it into a list"
self.setObject('data', self.validate_data(self.data))
fixupData = utility.upgradeLimit(fixupData, 146)
security.declarePrivate('populatorInformation')
def populatorInformation(self):
"return a string that this metods pair can read back to load data in this object"
if self.data:
return ' /-\ '.join(itertools.imap(str, self.data))
return ''
security.declarePrivate('populatorLoader')
def populatorLoader(self, string):
"load the data into this object if it matches me"
string = string.strip()
if string:
items = string.split(' /-\ ')
items = map(str.strip, items)
if items:
self.setObject('data', items)
class LookupTable(base.Base):
"LookupTable class"
meta_type = "LookupTable"
security = ClassSecurityInfo()
records = None
recordsLength = None
drawDict = base.Base.drawDict.copy()
drawDict['drawTable'] = 'drawTable'
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit short object"
format = "<p>Currently there are %s records</p><div>%s</div>"
if self.records is None:
self.records = OOBTree()
lenRecords = self.recordsLength(
) if self.recordsLength is not None else 0
return format % (lenRecords, self.create_button('clear', "Clear"))
security.declarePrivate('processRecorderChanges')
def processRecorderChanges(self, form):
"process the recorder changes"
clear = form.pop('clear', None)
if clear is not None:
self.clear()
security.declarePrivate('after_manage_edit')
def before_manage_edit(self, form):
"process the edits"
self.processRecorderChanges(form)
security.declareProtected('View management screens', "drawTable")
def drawTable(self):
"Render page"
temp = []
format = '<p>%s:%s</p>'
if self.records is not None:
for key, value in self.records.items():
temp.append(format % (repr(key), repr(value)))
return ''.join(temp)
security.declareProtected('Python Record Modification', 'insert')
def insert(self, key, value):
"modify this key and value into the OOBTree"
if self.records is None:
self.records = OOBTree()
if self.recordsLength is None:
self.setObject('recordsLength', BTrees.Length.Length())
if key not in self.records:
self.recordsLength.change(1)
self.records.insert(key, value)
security.declareProtected('Python Record Modification', 'add')
def add(self, key, value):
"this this key and value into the OOBTree"
if self.records is None:
self.records = OOBTree()
if self.recordsLength is None:
self.setObject('recordsLength', BTrees.Length.Length())
if key not in self.records:
self.recordsLength.change(1)
self.records[key] = value
security.declareProtected('Python Record Access', 'items')
def items(self, min=None, max=None):
"return the items in this OOBTree"
if self.records is None:
return []
return self.records.items(min, max)
security.declareProtected('Python Record Access', 'values')
def values(self, min=None, max=None):
"return the values of this OOBTree"
if self.records is None:
return []
return self.records.values(min, max)
security.declareProtected('Python Record Modification', 'update')
def update(self, collection):
"update our OOBTree with the data in collection"
if self.records is None:
self.records = OOBTree()
if self.recordsLength is None:
self.setObject('recordsLength', BTrees.Length.Length())
records = self.records
change = self.recordsLength.change
for key, value in collection.items():
if key not in records:
change(1)
records[key] = value
security.declareProtected('Python Record Access', 'keys')
def keys(self, min=None, max=None):
"return the keys of this OOBTree"
if self.records is None:
return []
return self.records.keys(min, max)
security.declareProtected('Python Record Modification', '__delitem__')
def __delitem__(self, key):
"delete this key from the OOBTree"
if self.records is not None:
del self.records[key]
self.recordsLength.change(-1)
security.declareProtected('Python Record Modification', 'remove')
def remove(self, key):
"delete this key from the OOBTree"
if self.records is not None:
del self.records[key]
self.recordsLength.change(-1)
security.declareProtected('Python Record Modification', '__setitem__')
def __setitem__(self, key, value):
"set this key and value in the OOBTree"
if self.records is None:
self.records = OOBTree()
self.records[key] = value
security.declareProtected('Python Record Access', '__getitem__')
def __getitem__(self, index):
"get this item from the OOBTree"
if self.records is not None:
return self.records[index]
raise KeyError, index
security.declareProtected('Python Record Access', 'get')
def get(self, key, default=None):
"get this item from the OOBTree"
if self.records is not None:
return self.records.get(key, default)
return default
security.declareProtected('Python Record Access', 'has_key')
def has_key(self, key):
"see if we have this key in the OOBTree"
if self.records is not None:
return self.records.has_key(key)
return False
security.declareProtected('Python Record Modification', 'clear')
def clear(self):
"clear the OOBTree"
self.setObject('records', None)
self.setObject('recordsLength', None)
security.declarePrivate("PrincipiaSearchSource")
def PrincipiaSearchSource(self):
"This is the basic search function"
return ''
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.createBTreeLength()
security.declarePrivate('createBTreeLength')
def createBTreeLength(self):
"remove Filters that are not being used"
if self.records is not None:
length = BTrees.Length.Length()
length.set(len(self.records))
self.setObject('recordsLength', length)
createBTreeLength = utility.upgradeLimit(createBTreeLength, 165)
class File(UserObject):
"File Class"
meta_type = "File"
security = ClassSecurityInfo()
data = None
fileSize = ''
openFileInNewWindow = 0
deletion = 1
showPreview = 1
showOpenInNewWindow = 0
urlExtension = ''
title = 'Download File'
filename = 'file'
fileUrl = ''
classConfig = {}
classConfig['deletion'] = {'name': 'deletion', 'type': 'radio'}
classConfig['showPreview'] = {'name': 'preview', 'type': 'radio'}
classConfig['showOpenInNewWindow'] = {
'name': 'showOpenInNewWindow',
'type': 'radio'
}
classConfig['openFileInNewWindow'] = {
'name': 'openFileInNewWindow',
'type': 'radio'
}
classConfig['urlExtension'] = {'name': 'urlExtension', 'type': 'tokens'}
classConfig['title'] = {'name': 'title', 'type': 'string'}
classConfig['filename'] = {'name': 'filename', 'type': 'string'}
classConfig['fileUrl'] = {'name': 'File Url', 'type': 'string'}
updateReplaceList = ('deletion', 'showPreview', 'showOpenInNewWindow',
'urlExtension', 'openFileInNewWindow')
configurable = ('openFileInNewWindow', )
security.declarePrivate('validate_title')
def validate_title(self, value):
"remove all leading and trailing whitespace"
temp = value
try:
temp = value.strip()
except AttributeError:
pass
if not temp:
temp = 'Download File'
return temp
security.declarePrivate('validate_filename')
def validate_filename(self, value):
"remove all leading and trailing whitespace"
temp = value
try:
temp = value.strip()
except AttributeError:
pass
if not temp:
temp = 'file'
return temp
security.declarePrivate('validate_urlExtension')
def validate_urlExtension(self, value):
"make sure we get rid of this if the value is false"
if value:
return value
else:
return ''
security.declarePublic("__bobo_traverse__")
def __bobo_traverse__(self, REQUEST, name):
"__bobo_traverse__"
if name.startswith('ver_'):
return Wrapper(name, self)
extensions = []
if self.getConfig('urlExtension'):
extensions = self.getConfig('urlExtension')
stack = self.REQUEST.TraversalRequestNameStack
if stack and stack[0] in extensions:
extension = stack[0]
self.REQUEST.TraversalRequestNameStack = []
return getattr(self, extension)
if self.exists() and name == self.filename:
if self.fileUrl:
return self.redir
object = self.data
type = object.content_type
if type == 'application/msword' or type == "":
type = 'application/octet-stream'
object.content_type = type
self.REQUEST.RESPONSE.setHeader('Content-Type', type)
return object.index_html
elif hasattr(self, name):
return getattr(self, name)
security.declareProtected('View', 'redirect_file_url')
def redirect_file_url(self):
"redirect to the real file"
return self.REQUEST.RESPONSE.redirect(
self.getUrlWithExtension(disableExtension=1))
security.declareProtected('View', 'redir')
def redir(self):
"redirect to the real file"
return self.REQUEST.RESPONSE.redirect(self.fileUrl)
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit short object"
temp = []
if self.showPreview:
preview = self.preview()
if preview:
temp.append(preview)
temp.append(self.editSingleConfig('title'))
temp.append(self.editSingleConfig('filename'))
temp.append(self.editSingleConfig('fileUrl'))
temp.append('<p>%s</p>' % self.input_file('data'))
if self.exists() and self.deletion:
temp.append('<p>Delete Current File: %s </p>' %
self.check_box('_del', 'Y'))
if self.showOpenInNewWindow:
temp.append(
'<p>Open File in New Window: %s </p>' % self.true_false(
'openFileInNewWindow', self.openFileInNewWindow, 0))
return ''.join(temp)
security.declarePrivate('before_manage_edit')
def before_manage_edit(self, dict):
"This is the object specific edit stuff"
delFile = dict.pop('_del', None)
if delFile == 'Y':
self.delObjects(('data', 'fileSize'))
data = dict.pop('data', None)
if data: #files are always uploaded but if the file has no data in it the test is false
try:
if not self.data:
self.manage_addProduct['File'].manage_addFile('data', data)
else:
self.data.manage_upload(data)
self.setFileSize()
self.updateFileContentType()
except ValueError: #catches no file uploaded
pass
def updateFileContentType(self):
"Update the content type of the installed file"
if self.exists():
if self.hasObject('data'):
file_obj = aq_base(self.data)
if hasattr(file_obj, 'data'):
filename, remove_after = utility.createTempFile(
file_obj.data)
file_obj.content_type = magicfile.magic(filename)
utility.removeTempFile(filename, remove_after)
def storeContentType(self, content_type):
"store the content type for to this object"
if self.exists():
self.data.content_type = content_type
security.declareProtected('View', 'getFileSize')
def getFileSize(self):
"Return the file size of this object"
return self.fileSize
security.declareProtected('View', 'view')
def view(self,
title='',
extension='',
disableExtension=None,
query=None,
url=None,
showSize=1,
openFileInNewWindow=None):
"Render page"
queryString = ''
if query is not None:
queryString = '?' + urllib.urlencode(query)
if not self.fileUrl and self.data == None:
pass
else:
if not title:
title = self.title
if url is None:
url = self.getUrlWithExtension(extension, disableExtension)
openFileInNewWindow = openFileInNewWindow if openFileInNewWindow is not None else self.getConfig(
'openFileInNewWindow')
if openFileInNewWindow:
target = 'target="_blank"'
else:
target = ''
if self.fileUrl:
fileSize = ''
elif showSize:
fileSize = self.getFileSize()
if fileSize:
fileSize = '(%s)' % fileSize
else:
fileSize = ''
return '<a href="%s%s" %s class="file">%s</a> %s' % (
url, queryString, target, title, fileSize)
return ""
security.declareProtected('View', 'getUrlWithExtension')
def getUrlWithExtension(self, extension='', disableExtension=None):
"process for a url extension and make sure it goes to a valid location otherwise just give back our current url"
urlExtension = self.getConfig('urlExtension')
if urlExtension and not (extension and extension in urlExtension):
extension = urlExtension[0]
if extension and not disableExtension:
try:
self.getCompoundDocContainer().restrictedTraverse(extension)
return urllib.quote(
os.path.join(self.absolute_url_path(), self.filename,
extension))
except KeyError:
pass
if self.fileUrl:
return self.fileUrl
else:
version = 'ver_%s' % int(
self.data.bobobase_modification_time().timeTime())
return os.path.join(self.absolute_url_path(), version,
urllib.quote(self.filename))
security.declarePrivate('setFileSize')
def setFileSize(self):
"Store the file size of this object"
try:
#0 length files should not have this field set
size = self.data.size
if size:
fileSize = utility.fileSizeString(size)
self.setObject('fileSize', fileSize)
except AttributeError:
pass
security.declareProtected("Access contents information", 'exists')
def exists(self):
"Check if object has data in it"
try:
return bool(self.data and hasattr(aq_base(self.data), 'data')
or self.fileUrl)
except AttributeError:
return 0
security.declareProtected('View management screens', 'preview')
def preview(self):
"Preview of a file"
if self.exists():
if self.fileUrl:
url = self.fileUrl
fileType = ''
fileSize = ''
else:
version = 'ver_%s' % int(
self.data.bobobase_modification_time().timeTime())
url = os.path.join(self.absolute_url_path(), version,
urllib.quote(self.filename))
fileType = self.data.content_type
fileSize = self.getFileSize()
title = self.title
return '<p>Preview: <a href="%s">%s</a> (%s) %s</p>' % (
url, title, fileSize, fileType)
return ""
security.declarePrivate("PrincipiaSearchSource")
def PrincipiaSearchSource(self):
"This is the basic search function"
obj = self.data
search = [self.title, self.filename]
if self.exists() and not self.fileUrl and obj.content_type.count(
"text"):
if isinstance(obj.data, ZODB.blob.Blob):
search.append(obj.data.open('r').read())
else:
search.append(str(obj.data))
return ' '.join(search)
security.declarePrivate('dataLoader')
def dataLoader(self, dict):
"load the data from this dict into this object"
self.before_manage_edit(dict)
self.filename.manage_edit(dict['filename'])
self.title.manage_edit(dict['title'])
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.updateTitle()
self.updateFilename()
self.updatePreview()
self.removeAttributeText()
self.changeUrlExtension()
self.fixFileId()
self.fixBlankFileName()
self.fixBlankTitle()
self.fixBlankFile()
security.declarePrivate('updateTitle')
def updateTitle(self):
"update the title object from a string to an AttributeText"
if isinstance(self.title, basestring):
return
if getattr(self.title, 'meta_type', None) != 'AttributeText':
if 'title' in self.objectConfig and hasattr(
self.objectConfig.title, 'value'):
self.addRegisteredObject('title',
'AttributeText',
data=self.title,
title=self.objectConfig.title.value)
else:
self.addRegisteredObject('title', 'AttributeText', data='')
updateTitle = utility.upgradeLimit(updateTitle, 141)
security.declarePrivate('updateFilename')
def updateFilename(self):
"update the filename object from a string to an AttributeText"
if getattr(self.filename, 'meta_type',
None) != 'AttributeText' and hasattr(
self.objectConfig.filename, 'value'):
self.addRegisteredObject('filename',
'AttributeText',
data=self.filename,
title=self.objectConfig.filename.value)
if getattr(self.filename, 'meta_type', None) != 'AttributeText':
self.addRegisteredObject('filename', 'AttributeText', data='')
updateFilename = utility.upgradeLimit(updateFilename, 141)
security.declarePrivate('updatePreview')
def updatePreview(self):
"fix the preview setting up"
if 'preview' in self.__dict__:
self.setObject('showPreview', self.preview)
self.delObjects(('preview', ))
updatePreview = utility.upgradeLimit(updatePreview, 141)
security.declarePrivate('removeAttributeText')
def removeAttributeText(self):
"remove the attributetext items and replace them with basic attributes"
self.fixupTitle()
self.fixupFileName()
removeAttributeText = utility.upgradeLimit(removeAttributeText, 150)
security.declarePrivate('fixupFileName')
def fixupFileName(self):
"fixup the filename attribute"
try:
filename = self.filename.data
self.delObjects(('filename', ))
self.setObject('filename', filename)
except AttributeError:
pass
security.declarePrivate('fixupTitle')
def fixupTitle(self):
"fixup the title attribute"
try:
title = self.title.data
self.delObjects(('title', ))
self.setObject('title', title)
except AttributeError:
pass
security.declarePrivate('changeUrlExtension')
def changeUrlExtension(self):
"change urlExtension to a sequence"
if self.urlExtension:
self.setObject('urlExtension', self.urlExtension.split())
changeUrlExtension = utility.upgradeLimit(changeUrlExtension, 151)
security.declarePrivate('fixFileId')
def fixFileId(self):
"change urlExtension to a sequence"
if self.data:
self.data.__name__ = 'data'
fixFileId = utility.upgradeLimit(fixFileId, 152)
security.declarePrivate('fixBlankFileName')
def fixBlankFileName(self):
"change urlExtension to a sequence"
if not self.filename:
self.filename = 'file'
fixBlankFileName = utility.upgradeLimit(fixBlankFileName, 170)
security.declarePrivate('fixBlankTitle')
def fixBlankTitle(self):
"change urlExtension to a sequence"
if not self.title:
self.title = 'Download File'
fixBlankTitle = utility.upgradeLimit(fixBlankTitle, 173)
security.declarePrivate('fixBlankFile')
def fixBlankFile(self):
"fix a bug where an empy file is uploaded"
if self.fileSize == '0.0 B': #we don't want to load the child object if we can avoid it
if self.data is None or not self.data.size:
self.delObjects(('data', 'fileSize'))
fixBlankFile = utility.upgradeLimit(fixBlankFile, 177)
class MethodManager(Base):
"IMethod object which binds a remote callable object"
security = ClassSecurityInfo()
meta_type = "MethodManager"
lookup = None
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit view"
temp = []
typeformat = '<div>name: %s path:%s</div>'
lookup = sorted(self.getLookup().items())
lookup.append(('', ''))
for index, (nameValue, pathValue) in enumerate(lookup):
temp.append(
typeformat %
(self.input_text(
'name', nameValue, containers=('lookup', str(index))),
self.input_text(
'path', pathValue, containers=('lookup', str(index)))))
return ''.join(temp)
security.declarePrivate('before_manage_edit')
def before_manage_edit(self, dict):
"Process edits."
lookup = dict.pop('lookup', None)
if lookup is not None:
temp = {}
for i, j in lookup.items():
temp[int(i)] = j
temp = ((dictionary['name'].strip(), dictionary['path'].strip())
for index, dictionary in sorted(temp.iteritems))
cleaned = [(name, display) for name, display in temp
if name and display]
if len(cleaned):
temp = {}
for name, display in cleaned:
temp[name] = display
self.setObject('lookup', temp)
else:
self.delObjects(('lookup', ))
security.declarePrivate('getMethod')
def getMethod(self, name):
"Inline draw view"
cdoc = self.getCompoundDocContainer()
path = self.getLookup()[name]
item = cdoc.restrictedTraverse(path, None)
if item is not None:
return cdoc.changeCallingContext(item)
security.declareProtected('Access contents information', '__contains__')
def __contains__(self, name):
"see if name is in me"
return name in self.getLookup()
security.declarePrivate('getLookup')
def getLookup(self):
"get the current lookup variable"
if self.lookup is not None:
return self.lookup
return {}
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.transferAndDelete()
security.declarePrivate('transferAndDelete')
def transferAndDelete(self):
"transfer all the data to the LinkManager object and delete this one"
cdoc = self.getCompoundDoc()
link = cdoc.LinkManager
for name, path in self.getLookup().items():
link.addPath(path)
cdoc.delObjects([self.getId()])
transferAndDelete = utility.upgradeLimit(transferAndDelete, 147)
class DisplayUserAgent(Base):
"DisplayFilter apply this to an object to change how it outputs"
meta_type = "DisplayUserAgent"
security = ClassSecurityInfo()
overwrite = 1
data = ''
clients = None
setused = ''
operatingSystems = None
security.declarePrivate('before_manage_edit')
def before_manage_edit(self, dict):
"process the edits"
userAgentSelect = dict.pop('userAgentSelect', None)
if userAgentSelect is not None:
self.setClients({})
try:
del dict['userAgent']
except KeyError:
pass
operatingSystems = dict.pop('operatingSystems', None)
if operatingSystems is not None:
allowedOS = useragent.UserAgent.getAllowedOperatingSystems
temp = [i for i in operatingSystems if i in allowedOS]
if temp:
self.setObject('operatingSystems', temp)
userAgent = dict.pop('userAgent', None)
if userAgent is not None:
seq = []
for i in userAgent:
i = i.split(' ')
length = 4 - len(i)
i.extend([''] * length)
seq.append(tuple(i))
clients = utility.mergeSequenceTree(seq)
if clients:
self.setClients(clients)
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit view"
return "<p>UserAgent Set : %s</p>\n" % self.option_select(
self.clientSets(), 'setused', [self.setused])
security.declarePrivate('setClients')
def setClients(self, clients):
"set the clients for this object"
if not clients:
clients = None
self.setObject('clients', clients)
security.declarePrivate('getClients')
def getClients(self):
"Get the clients of this object"
if self.setused:
return self.getSetClients()
if self.clients is not None:
return self.clients
return {}
def clientSets(self):
"returns a list of the client sets that we have"
return self.clientSetMapping().keys()
def clientSetMapping(self):
"Return a dict of sets, funcname mappings"
sets = {}
sets['XHTML 1.0 CSS1'] = 'XHTML10CSS1'
sets['XHTML 1.0 CSS2'] = 'XHTML10CSS2'
sets['HTML4'] = 'HTML4'
sets['MSIE 5 and 6'] = 'MSIE56'
sets['No Detection'] = 'noDetection'
sets[''] = ''
return sets
def getSetClients(self):
"Return the clients that matches this set name"
setname = self.setused
if setname in self.clientSets():
funcname = self.clientSetMapping()[setname]
return getattr(self, funcname)()
def XHTML10CSS1(self):
"Opera 5 and 6, MSIE 5 and 6"
return {
'': {
'Opera': {
'6': {
'': {}
},
'5': {
'': {}
}
}
},
'Mozilla/4': {
'MSIE': {
'6': {
'': {}
},
'5': {
'': {}
}
}
}
}
def XHTML10CSS2(self):
"Mozilla/5 and the W3C_Validator selected"
return {
'Mozilla/5': {
'': {
'': {
'': {}
}
}
},
'': {
'W3C_Validator': {
'': {
'': {}
}
}
}
}
def HTML4(self):
"Mozilla/4 browsers selected"
return {'Mozilla/4': {'': {'': {'': {}}}}}
def MSIE56(self):
"Only IE 5 and 6 selected"
return {'Mozilla/4': {'MSIE': {'6': {'': {}}, '5': {'': {}}}}}
def noDetection(self):
"No UserAgents selected"
return {}
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.repairSetused()
self.removeBlankOSClients()
security.declarePrivate('repairSetused')
def repairSetused(self):
"fix the xhtml entry for set used"
if self.setused == 'XTML 1.0 CSS2':
self.setused = 'XHTML 1.0 CSS2'
repairSetused = utility.upgradeLimit(repairSetused, 141)
security.declarePrivate('removeBlankOSClients')
def removeBlankOSClients(self):
"remove blank operatingSystems and clients entries"
if not self.clients:
self.delObjects(['clients'])
if not self.operatingSystems:
self.delObjects(['operatingSystems'])
removeBlankOSClients = utility.upgradeLimit(removeBlankOSClients, 161)
class Display(base.Base):
"This is a dispatcher for display filter objects based on the type of viewer request"
meta_type = "Display"
security = ClassSecurityInfo()
overwrite = 1
#quick hack remove later with a usage object
security.declarePrivate('getAllowedUsages')
def getAllowedUsages(self):
"Get the allowed usages of a Display"
return ['edit', 'view']
description = ''
usage = 'view'
defaultFilter = ''
security.declarePrivate('afterDeleteRegisteredObject')
def afterDeleteRegisteredObject(self, name):
"do something after a registered object is deleted"
self.setAutoDefaultFilter()
security.declarePrivate('afterAddRegisteredObject')
def afterAddRegisteredObject(self, name, metatype):
"do something after a registered object has been added"
if metatype == 'DisplayFilter':
self.setAutoDefaultFilter()
security.declarePrivate('after_manage_edit')
def after_manage_edit(self, dict):
"after a display is edited notify the parent of our usage"
self.DisplayManager.addMapping(self.getId())
self.DisplayManager.cleanupDefaultDisplays(self)
security.declareProtected('View', 'view')
def view(self):
"Inline draw view"
filters = self.objectValues('DisplayFilter')
if len(filters) == 1:
f = filters[0]
if not 'header' in self.REQUEST.other: #used to check if a render is already default
if not 'DisplayFilter' in self.REQUEST.other:
self.REQUEST.other['DisplayFilter'] = f
return f.view()
filters = sorted(i.willRender() for i in filters)
if filters:
first = filters.pop()
#check for match on browser and language
if first[0] != 0:
filter = first.pop()
if not 'DisplayFilter' in self.REQUEST.other:
self.REQUEST.other['DisplayFilter'] = filter
return filter.view()
if self.defaultFilter:
filter = getattr(self, self.defaultFilter)
if not 'DisplayFilter' in self.REQUEST.other:
self.REQUEST.other['DisplayFilter'] = filter
return filter.view()
else:
return ''
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit view"
temp = [
"<p>Usage is : %s</p>\n" %
self.option_select(self.getAllowedUsages(), 'usage', [self.usage])
]
displayIds = self.objectIds('DisplayFilter')
if displayIds:
temp.append("<p>Default Filter is : %s</p>\n" % self.option_select(
displayIds, 'defaultFilter', [self.defaultFilter]))
temp.append(self.addDeleteObjectsEdit())
temp.append('<p>Description:</p>')
temp.append(self.text_area('description', self.description))
return ''.join(temp)
security.declarePrivate('restrictedUserObject')
def restrictedUserObject(self):
"Return a list of the types that are allowed to be added or deleted from this object by a user"
return ['DisplayFilter']
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"Return what can be search which is nothing"
return ''
security.declarePrivate("setAutoDefaultFilter")
def setAutoDefaultFilter(self):
"set the default filter to a filter if one is not already set"
filters = self.objectIds('DisplayFilter')
currentFilter = self.defaultFilter
if currentFilter not in filters:
currentFilter = None
if not currentFilter and len(filters):
self.setObject("defaultFilter", filters[0])
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.upgraderChangeDisplayObjectRef()
self.removeOldVars()
security.declarePrivate('removeOldVars')
def removeOldVars(self):
"remove some old variables"
self.delObjects(['alias', 'registeredFilters'])
removeOldVars = utility.upgradeLimit(removeOldVars, 141)
security.declarePrivate('upgraderChangeDisplayObjectRef')
def upgraderChangeDisplayObjectRef(self):
"Change the object refs in default edit to a name instead"
id = self.getId()
default = 'defaultFilter'
self.delObjects([id + 'edit'])
try:
self.setObject(default, getattr(self, default).getId())
except AttributeError:
pass
upgraderChangeDisplayObjectRef = utility.upgradeLimit(
upgraderChangeDisplayObjectRef, 141)
class TabManager(BaseTab):
"TabManager manages multiple tabs in the edit interface"
meta_type = "TabManager"
security = ClassSecurityInfo()
overwrite = 1
displayType = 'edit'
active = 0
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"This is the basic search function"
return ''
security.declareProtected('View', 'view')
def view(self, doc=None, renderer=None, tabScript=None):
"Inline draw view"
if doc is None:
doc = self.getCompoundDoc()
renderer = renderer or self.getConfig('renderer')
if self.getTabActive():
editname = self.getDisplayName()
menu = []
url = doc.absolute_url_path()
for name, clickableName, cssClass, queryDict, query in self.getTabOrder(
doc=doc, tabScript=tabScript):
selected = 0
if self.getTabMapping(
name) == editname and utility.dictInQuery(
queryDict, query):
selected = 1
query = query.copy()
query.update(queryDict)
menu.append(('%s/manage_workspace/%s' % (url, name),
clickableName, selected, cssClass, query, ''))
cssClass = ' class="tabControl"' if renderer != 'Themeroller Tabs' else ''
return '<div%s>%s</div>' % (cssClass,
NestedListURL.listRenderer(
renderer, menu, self.columns))
return ""
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit view"
format = '<div class="outline"><p>%s</p>%s</div>'
return format % (self.editSingleConfig('active'), BaseTab.edit(self))
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
BaseTab.classUpgrader(self)
self.fixupTabOrder()
self.fixupTabMapping()
security.declarePrivate('fixupTabOrder')
def fixupTabOrder(self):
"fixup the tabOrder attribute"
if not self.tabOrder:
self.setObject('tabOrder', None)
fixupTabOrder = utility.upgradeLimit(fixupTabOrder, 141)
security.declarePrivate('fixupTabMapping')
def fixupTabMapping(self):
"fixup the tabMapping attribute"
if not self.tabMapping:
self.setObject('tabMapping', None)
fixupTabMapping = utility.upgradeLimit(fixupTabMapping, 141)
class TextArea(UserObject):
"TextArea class"
meta_type = "TextArea"
security = ClassSecurityInfo()
data = ''
renderCache = ''
struct = 1
structstate = 1
configurable = ('structstate', )
security.declareProtected('View management screens', 'edit')
def edit(self, struct=None, *args, **kw):
"Inline edit short object"
temp = self.text_area('data', self.data)
if struct is not None:
struct = self.struct
if struct:
format = '<div>%s Click "No" if you don\'t want your text auto-formatted.</div>'
temp = temp + format % self.editSingleConfig('structstate')
return temp
security.declareProtected('View', 'view')
def view(self):
"Render page"
return self.renderCache or self.data
security.declarePrivate('after_manage_edit')
def after_manage_edit(self, form):
"update the render cache after all other changes"
self.updateCache()
security.declarePrivate('updateCache')
def updateCache(self):
"update the cache of this object if applicable"
if self.getConfig('structstate'):
self.setObject('renderCache',
str(nocodestructured.HTML(self.data, header=0)))
else:
self.delObjects([
'renderCache',
])
classConfig = {}
classConfig['struct'] = {'name': 'struct', 'type': 'radio'}
classConfig['structstate'] = {
'name': 'Structured Text Enabled',
'type': 'radio'
}
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.upgraderReplaceStructured()
self.fixRenderCache()
security.declarePrivate('upgraderReplacedStructured')
def upgraderReplaceStructured(self):
"replace structured object attribute with structstate config"
if self.hasObject('structured'):
structured = self.structured
if structured == 'Y':
structured = 1
elif structured == 'N':
structured = 0
self.setObject('structstate', int(structured))
self.delObjects(['structured'])
upgraderReplaceStructured = utility.upgradeLimit(upgraderReplaceStructured,
141)
security.declarePrivate('fixRenderCache')
def fixRenderCache(self):
"remove renderCache if stx is not enabled"
self.updateCache()
fixRenderCache = utility.upgradeLimit(fixRenderCache, 154)
configKeep = ('structstate', )
security.declarePrivate('configLoader')
def configLoader(self, config):
"load the config object for this textarea object"
if config.hasObject('meta_type') and config.meta_type == 'Config':
config = config.convertToDict()
replaceEntries = [key for key in config if key not in self.configKeep]
for key in replaceEntries:
self.setObject(key, config[key])
security.declarePrivate('populatorInformation')
def populatorInformation(self):
"return a string that this metods pair can read back to load data in this object"
return self.data.replace('\n', '\\n')
security.declarePrivate('populatorLoader')
def populatorLoader(self, string):
"load the data into this object if it matches me"
self.setObject('data', string.replace('\\n', '\n'))
self.updateCache()
security.declareProtected('Change CompoundDoc', 'store')
def store(self, string):
"set the calculation value of this object"
self.setObject('data', str(string))
self.updateCache()
class Picture(BasePicture):
"Image class"
meta_type = "Picture"
security = ClassSecurityInfo()
imagesrc = '' #obsolete
imagesrc_template = ''
data = None
image = None
fileSize = ''
deletion = 1
preview = 1
showTags = 1
showAlt = 1
showURL = 1
url = ''
alt = ''
tags = ''
thumbnail = None
resizeOnUpload = 0
resaveOnUpload = 1
classConfig = BasePicture.classConfig.copy()
classConfig['deletion'] = {'name': 'deletion', 'type': 'radio'}
classConfig['preview'] = {'name': 'preview', 'type': 'radio'}
classConfig['showTags'] = {'name': 'showTags', 'type': 'radio'}
classConfig['resaveOnUpload'] = {
'name': 'Resave Images on Upload',
'type': 'radio'
}
classConfig['tags'] = {'name': 'tags', 'type': 'string'}
classConfig['alt'] = {'name': 'alt', 'type': 'string'}
classConfig['url'] = {'name': 'url', 'type': 'string'}
classConfig['showAlt'] = {'name': 'showAlt', 'type': 'radio'}
classConfig['showURL'] = {'name': 'showURL', 'type': 'radio'}
classConfig['resizeOnUpload'] = {
'name': 'Resize uploaded images?',
'type': 'radio'
}
configurable = BasePicture.configurable + (
'deletion', 'showAlt', 'showTags', 'showURL', 'preview',
'scriptChangePath', 'resizeOnUpload', 'resaveOnUpload')
attr_notified = set([
'url', 'alt', 'tags', 'showUrl', 'showAlt', 'showTags', 'preview',
'deletion', 'data'
])
security.declareProtected('View management screens', 'edit')
def edit(self,
showTags=None,
showAlt=None,
showURL=None,
preview=None,
*args,
**kw):
"Inline edit short object"
temp = []
if preview is None:
preview = self.getConfig('preview')
if self.exists() and preview:
object = self.data
width, height = object.width, object.height
size = self.getFileSize()
if not size:
self.setFileSize()
size = self.getFileSize()
type = object.content_type
format = '<p>Preview: %s (%s px/%s px) %s %s </p>'
temp.append(format % (self.small(), width, height, size, type))
if showTags is None:
showTags = self.getConfig('showTags')
if showTags:
temp.append(self.editSingleConfig('tags'))
if showAlt is None:
showAlt = self.getConfig('showAlt')
if showAlt:
temp.append(self.editSingleConfig('alt'))
if showURL is None:
showURL = self.getConfig('showURL')
if showURL:
temp.append(self.editSingleConfig('url'))
temp.append('<div>%s</div><p>Click [Browse] to enter the picture</p>' %
self.input_file('data'))
if self.getConfig('deletion') and self.exists():
temp.append('<p>Delete Current Image: %s </p>' %
self.check_box('_del', 'Y'))
return ''.join(temp)
security.declarePrivate('before_manage_edit')
def before_manage_edit(self, dict):
"This is the object specific edit stuff"
if dict.pop('_del', None) == 'Y':
self.clear()
if dict.get('data',
None): #don't process if data does not have anything in it
filename, remove_after = utility.createTempFile(dict['data'])
content_type = magicfile.magic(filename)
if content_type.startswith('image'):
if not self.data:
self.manage_addProduct['Image'].manage_addImage(
'data', '', 'data')
if self.getConfig('resizeOnUpload'):
self.resizeImage(filename)
elif self.getConfig('resaveOnUpload'):
temp_file, x, y = utility.resaveExistingImage(filename)
if temp_file is not None:
self.data.manage_upload(temp_file)
temp_file.close()
self.data.width = x
self.data.height = y
else:
self.data.manage_upload(open(filename, 'rb'))
else:
self.data.manage_upload(open(filename, 'rb'))
self.updateParentPaths(set(['data']))
self.makeThumbnail(filename)
self.setFileSize()
self.storeContentType(content_type)
utility.removeTempFile(filename, remove_after)
try:
del dict['data']
except KeyError:
pass
security.declareProtected('Change CompoundDoc', 'clear')
def clear(self):
"clear this image"
if self.getConfig('deletion'):
self.delObjects(('data', 'imagesrc', 'thumbnail', 'fileSize',
'imagesrc_template'))
security.declarePrivate('after_manage_edit')
def after_manage_edit(self, dict):
"cache some information after this object has been modified"
if self.hasBeenModified():
self.updateImageSrcCache()
security.declareProtected('Change CompoundDoc', 'resizeImage')
def resizeImage(self, filename):
"generate this image"
image = PIL.Image.open(filename)
if image.mode != self.getConfig('color'):
image = image.convert(self.getConfig('color'))
maxWidth = self.getConfig('width')
maxHeight = self.getConfig('height')
crop_left = self.getConfig('crop_left')
crop_upper = self.getConfig('crop_upper')
crop_right = self.getConfig('crop_right')
crop_lower = self.getConfig('crop_lower')
if crop_right and crop_lower:
image = image.crop((crop_left, crop_upper, crop_right, crop_lower))
(x, y) = image.size
if x > maxWidth:
y = y * maxWidth / x
x = maxWidth
if y > maxHeight:
x = x * maxHeight / y
y = maxHeight
if x == 0:
x = 1
if y == 0:
y = 1
image = image.resize((x, y))
tempFile = utility.saveImage(image, self.getConfig('format'))
self.data.manage_upload(tempFile)
self.data.width = x
self.data.height = y
security.declareProtected('Change CompoundDoc', 'resaveExistingImage')
def resaveExistingImage(self):
"reisze existing images"
if self.exists():
filename, remove_after = utility.createTempFile(self.data.data)
content_type = magicfile.magic(filename)
if content_type.startswith('image'):
if self.getConfig('resaveOnUpload'):
temp_file, x, y = utility.resaveExistingImage(filename)
beforeSize = utility.fileSizeToInt(self.getFileSize())
if temp_file is not None and os.stat(
temp_file.name)[stat.ST_SIZE] < beforeSize:
if not self.data:
self.manage_addProduct['Image'].manage_addImage(
'data', temp_file, 'data')
else:
self.data.manage_upload(temp_file)
self.data.width = x
self.data.height = y
#have to redo the content_type after we modify the image in case it has changed
content_type = magicfile.magic(temp_file.name)
temp_file.close()
self.setFileSize()
self.storeContentType(content_type)
utility.removeTempFile(filename, remove_after)
security.declareProtected('Change CompoundDoc', 'resizeExistingImage')
def resizeExistingImage(self):
"resize existing images"
if self.exists():
filename, remove_after = utility.createTempFile(self.data.data)
content_type = magicfile.magic(filename)
if content_type.startswith('image'):
if self.getConfig('resizeOnUpload'):
self.resizeImage(filename)
#have to redo the content_type after we modify the image in case it has changed
content_type = magicfile.magic(filename) #not correct
self.makeThumbnail(filename)
self.setFileSize()
self.storeContentType(content_type)
self.updateImageSrcCache()
utility.removeTempFile(filename, remove_after)
security.declareProtected('Change CompoundDoc', 'updateImageSrcCache')
def updateImageSrcCache(self):
"update the imagesrc cache string"
if self.exists():
decode = {}
decode['height'] = self.data.height
decode['width'] = self.data.width
if com.detection.no_dtml(self.alt):
decode['alt'] = self.convert(self.alt)
else:
decode['alt'] = self.alt
decode['tags'] = self.tags
self.setObject('imagesrc_template',
image_template.safe_substitute(decode))
security.declareProtected('View', 'view')
def view(self,
urlCallable=None,
parent=None,
additionalAttributes='',
drawHref=1,
url_data=None):
"Render page"
parent = parent or self.getCompoundDocContainer()
if self.exists():
decode = {}
decode['url'] = self.absolute_url_path_extension()
decode['additionalAttributes'] = additionalAttributes
if not self.imagesrc_template:
self.REQUEST.other['okayToRunNotification'] = 0
self.updateImageSrcCache()
self.delObjects(['imagesrc'])
image = Template(self.imagesrc_template).safe_substitute(decode)
url_data = url_data if url_data is not None else self.url
if drawHref and url_data:
href = com.html.generate_url(url_data,
parent,
self.REQUEST,
url_callable=urlCallable)
if href is not None:
image = '<a href="%s">%s</a>' % (href, image)
return image
return ""
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"This is the basic search function"
if self.exists():
return str(self.alt)
else:
return ""
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.fixupAlt()
self.fixupUrl()
self.fixupTags()
self.removeAttributeText()
self.fixFileId()
self.convert_to_template()
security.declarePrivate('fixupAlt')
def fixupAlt(self):
"fix up the alt attribute"
alt = getattr(self, 'alt', '')
if getattr(alt, 'meta_type', None) != 'AttributeText':
self.addRegisteredObject('alt', 'AttributeText', data=alt)
fixupAlt = utility.upgradeLimit(fixupAlt, 141)
security.declarePrivate('fixupUrl')
def fixupUrl(self):
"fix up the url attribute"
url = getattr(self, 'url', '')
if getattr(url, 'meta_type', None) != 'AttributeText':
self.addRegisteredObject('url', 'AttributeText', data=url)
fixupUrl = utility.upgradeLimit(fixupUrl, 141)
security.declarePrivate('fixupTags')
def fixupTags(self):
"fix up the tags attribute"
tags = getattr(self, 'tags', '')
if getattr(tags, 'meta_type', None) != 'AttributeText':
self.addRegisteredObject('tags', 'AttributeText', data=tags)
fixupTags = utility.upgradeLimit(fixupTags, 141)
security.declarePrivate('removeAttributeText')
def removeAttributeText(self):
"remove the attributetext items and replace them with basic attributes"
for name, value in self.objectItems('AttributeText'):
self.delObjects((name, ))
self.setObject(name, value.data)
self.updateImageSrcCache()
removeAttributeText = utility.upgradeLimit(removeAttributeText, 148)
security.declarePrivate('convert_to_template')
def convert_to_template(self):
"convert to a template"
self.updateImageSrcCache()
self.delObjects(['imagesrc'])
convert_to_template = utility.upgradeLimit(convert_to_template, 176)
class MixUpgrader(BaseObject):
"this is a mixin class to give objects a auto upgrade capability"
meta_type = "MixUpgrader"
security = ClassSecurityInfo()
security.declarePrivate('upgrader')
def upgrader(self):
"performUpgrades to the objet"
self.fixObjectIdAndName()
self.fixConfigId()
self.removeAttributeConfig()
self.fixupCacheSystem()
self.removeObjectAndStateAttributes()
self.upgraderRepairAttributes()
self.createMetaMapping()
self.upgraderRemoveParentMCP()
self.fixupObserverSystem()
self.removeDataAttribute()
self.upgradeObjectConfigOrRemoveIt()
self.undoMasterSharing()
self.doClassSpecificUpgrades()
self.resetCreateConfigDefault()
self.removeItemsSpecificToCompoundDoc()
self.resetTextAreaCaches()
self.updateFilePictureMetaInformation()
self.removeEditCache()
self.removeNestedListURLObjects()
self.removeManageEditFormInstances()
self.removeItemsThatAreDefault()
self.mergeObjectConfigIntoObject()
self.removeOwnerFromAttributes()
security.declarePrivate('removeItemsThatAreDefault')
def removeItemsThatAreDefault(self):
"remove the items in this object that are the same as the class default items"
for name, value in self.__dict__.items():
if hasattr(self.__class__, name) and getattr(self.__class__,
name) == value:
delattr(self, name)
removeItemsThatAreDefault = utility.upgradeLimit(removeItemsThatAreDefault,
141)
security.declarePrivate('mergeObjectConfigIntoObject')
def mergeObjectConfigIntoObject(self):
"remove objectConfig and merge its information into its parents object"
if 'objectConfig' in self.__dict__:
for name, value in self.objectConfig.items():
if name in self.classConfig:
self.setObject(name, value)
self.delObjects(['objectConfig'])
mergeObjectConfigIntoObject = utility.upgradeLimit(
mergeObjectConfigIntoObject, 141)
security.declarePrivate('removeManageEditFormInstances')
def removeManageEditFormInstances(self):
"remove the mamange edit form objects from stuff that is not a CompoundDoc object"
if self.meta_type != 'CompoundDoc':
self.delObjects(self.objectIds('ManageEditForm'))
removeManageEditFormInstances = utility.upgradeLimit(
removeManageEditFormInstances, 141)
security.declarePrivate('fixObjectIdAndName')
def fixObjectIdAndName(self):
"fix the id and __name__ attributes of an object"
sdict = self.__dict__
if not 'id' in sdict and '__name__' in sdict:
self.id = self.__name__
del self.__name__
if '__name__' in sdict:
del self.__name__
fixObjectIdAndName = utility.upgradeLimit(fixObjectIdAndName, 141)
security.declarePrivate('removeAttributeConfig')
def removeAttributeConfig(self):
"remove the config attribute if we have one"
if 'config' in self.__dict__:
del self.__dict__['config']
removeAttributeConfig = utility.upgradeLimit(removeAttributeConfig, 141)
security.declarePrivate('removeNestedListURLObjects')
def removeNestedListURLObjects(self):
"remove the config attribute if we have one"
self.delObjects(self.objectIds('NestedListURL'))
removeNestedListURLObjects = utility.upgradeLimit(
removeNestedListURLObjects, 141)
security.declarePrivate('fixupCacheSystem')
def fixupCacheSystem(self):
"fixed the editCache object if it is not the right type"
self.delObjects(['cacheNameEdit'])
fixupCacheSystem = utility.upgradeLimit(fixupCacheSystem, 141)
security.declarePrivate('fixupObserverSystem')
def fixupObserverSystem(self):
"fix the observer system by"
sdict = self.__dict__
if 'observing' in sdict and not self.observing:
self.delObjects(['observing'])
if 'observed' in sdict:
self.delObjects(['observed'])
if 'observing' in sdict:
self.upgraderRemoveDuplicateObservingEntries()
self.upgraderChangeObservationPath()
fixupObserverSystem = utility.upgradeLimit(fixupObserverSystem, 141)
security.declarePrivate('removeDataAttribute')
def removeDataAttribute(self):
"removed the data attribute from all objects that should not have it"
if self.meta_type in [
'ControlPanel', 'ControlProfileManager',
'ControlCatalogManager', 'ControlDebugObject',
'ControlEditManager', 'ControlEventManager',
'ControlViewManager', 'ControlConfigManger', 'ControlAddDel',
'ControlRequest', 'ControlDisplayManager', 'ControlLicense',
'ControlLog', 'ControlTabManager', 'Display', 'DisplayFilter',
'DisplayManager', 'DisplayUserAgent'
]:
self.delObjects(['data'])
removeDataAttribute = utility.upgradeLimit(removeDataAttribute, 141)
security.declarePrivate('doClassSpecificUpgrades')
def doClassSpecificUpgrades(self):
"do the upgrades specific to a class"
if hasattr(aq_base(self), 'classUpgrader'):
self.classUpgrader()
security.declarePrivate('upgradeObjectConfigOrRemoveIt')
def upgradeObjectConfigOrRemoveIt(self):
"upgrade the objectConfig object where appropriate and remove it otherwise"
if 'objectConfig' in self.__dict__ and self.meta_type not in [
'Config', 'Entry'
]:
if hasattr(aq_base(self), 'classConfig'):
if hasattr(aq_base(self.objectConfig), 'classUpgrader'):
self.objectConfig.classUpgrader()
else:
self.delObjects(['objectConfig'])
upgradeObjectConfigOrRemoveIt = utility.upgradeLimit(
upgradeObjectConfigOrRemoveIt, 141)
security.declarePrivate('undoMasterSharing')
def undoMasterSharing(self):
"copy the remove shared objects locally since we are not a master document"
if self.meta_type == 'CompoundDoc':
if self.masterLocation is not None:
if self.masterLocation != self.getPath():
master = self.unrestrictedTraverse(self.masterLocation,
None)
if master is not None and master.meta_type == 'CompoundDoc':
self.setObject(
'CatalogManager',
aq_base(master.CatalogManager)._getCopy(master))
self.setObject(
'TabManager',
aq_base(master.TabManager)._getCopy(master))
self.setObject(
'EventManager',
aq_base(master.EventManager)._getCopy(master))
undoMasterSharing = utility.upgradeLimit(undoMasterSharing, 141)
security.declarePrivate('resetCreateConfigDefault')
def resetCreateConfigDefault(self):
"reset the var called createConfigDefault if it is not correct or should not exist"
if 'createConfigDefault' in self.__dict__:
self.delObjects(['createConfigDefault'])
resetCreateConfigDefault = utility.upgradeLimit(resetCreateConfigDefault,
141)
security.declarePrivate('removeItemsSpecificToCompoundDoc')
def removeItemsSpecificToCompoundDoc(self):
"remove items from various objects that only compounddoc objects should have"
sdict = self.__dict__
if self.meta_type != 'CompoundDoc':
if self.objectIds('ManageEditForm'):
self.upgraderRemoveManage()
if 'objectVersion' in sdict:
self.delObjects(['objectVersion'])
if 'updateVersion' in sdict:
self.delObjects(['updateVersion'])
if 'userModificationTimeStamp' in sdict:
self.delObjects(['userModificationTimeStamp'])
removeItemsSpecificToCompoundDoc = utility.upgradeLimit(
removeItemsSpecificToCompoundDoc, 141)
security.declarePrivate('resetTextAreaCaches')
def resetTextAreaCaches(self):
"reset the caches of text areas"
sdict = self.__dict__
if self.meta_type in ['TextArea', 'SectionText']:
if 'cachedSTX' in sdict:
self.delObjects(['cachedSTX'])
if not 'renderCache' in sdict:
self.updateCache()
resetTextAreaCaches = utility.upgradeLimit(resetTextAreaCaches, 141)
security.declarePrivate('updateFilePictureMetaInformation')
def updateFilePictureMetaInformation(self):
"update the meta information attached to files and pictures"
if self.meta_type in ['File', 'Picture']:
self.setFileSize()
self.updateFileContentType()
updateFilePictureMetaInformation = utility.upgradeLimit(
updateFilePictureMetaInformation, 141)
security.declarePrivate('removeEditCache')
def removeEditCache(self):
"if we have a var called editCache remove it"
self.delObjects(['editCache'])
removeEditCache = utility.upgradeLimit(removeEditCache, 141)
security.declarePrivate('fixConfigId')
def fixConfigId(self):
"Fix the id of the config object since a bug at one point allowed an entry to be called id"
config = getattr(self, 'objectConfig', None)
if config is not None and config == 'Config':
if not 'id' in self.__dict__:
config.id = 'objectConfig'
if hasattr(config.id,
'meta_type') and config.id.meta_type == 'Entry':
config.setObject('showId', aq_base(config.id))
config.delObjects(['id'])
config.id = 'objectConfig'
fixConfigId = utility.upgradeLimit(fixConfigId, 141)
security.declarePrivate('removeObjectAndStateAttributes')
def removeObjectAndStateAttributes(self):
"remove the object and state attributes"
try:
del self.object
except (AttributeError, KeyError):
pass
try:
del self.state
except (AttributeError, KeyError):
pass
removeObjectAndStateAttributes = utility.upgradeLimit(
removeObjectAndStateAttributes, 141)
security.declarePrivate('createMetaMapping')
def createMetaMapping(self):
"Create a meta_type mapping for each object that has one to speed up lookups by type"
#Items should be fixing their entires automatically and cleanup should not happen here
#It screws up the ObjectRecords since they have entries that are in a subobject that
#uses a getattr to catch those requests and this would remove those entries.
temp = []
for name, item in self.__dict__.items():
if getattr(item, 'meta_type', None):
temp.append({'id': name, 'meta_type': item.meta_type})
if self.meta_type == 'ObjectRecorder':
meta = self.recordType
if meta is not None:
for key in self.getRecordKeys():
temp.append({'id': key, 'meta_type': meta})
temp = tuple(sorted(temp))
if self._objects != temp:
self.setObject('_objects', temp)
createMetaMapping = utility.upgradeLimit(createMetaMapping, 141)
security.declarePrivate('upgraderRepairAttributes')
def upgraderRepairAttributes(self):
"repair attributes that got created too soon and so caused the upgrader to abort"
if self.meta_type in ['CompoundDoc', 'Config', 'Entry']:
return None
name = self.getId()
trans = {}
trans[name + 'data'] = 'data'
trans[name + 'title'] = 'title'
trans[name + 'filename'] = 'filename'
trans[name + 'fileSize'] = 'fileSize'
trans[name + 'tags'] = 'tags'
trans[name + 'alt'] = 'alt'
trans[name + 'principiaSearch'] = 'principiaSearch'
trans[name + 'code'] = 'code'
trans[name + 'codetype'] = 'codetype'
trans[name + 'required'] = 'required'
trans[name + 'optional'] = 'optional'
trans[name + 'clients'] = 'clients'
trans[name + 'language'] = 'language'
trans[name + 'structured'] = 'structured'
trans[name + 'cachedSTX'] = 'cachedSTX'
trans[name + 'description'] = 'description'
trans[name + 'alias'] = 'alias'
trans[name + 'usage'] = 'usage'
trans[name + 'registeredFilters'] = 'registeredFilters'
trans[name + 'registered'] = 'registeredFilters'
trans[name + 'defaultFilter'] = 'defaultFilter'
trans[name + 'defaultEdit'] = 'defaultEdit'
trans[name + 'defaultView'] = 'defaultView'
trans[name] = 'data'
trans[name + 'MCP'] = 'MCP'
trans[name + 'Parents'] = 'Parents'
trans[name + 'mode'] = 'mode'
trans[name + 'objectPath'] = 'objectPath'
trans[name + 'useCatalog'] = 'useCatalog'
sdict = self.__dict__
for oldName, newName in trans.items():
if oldName in sdict:
oldItem = getattr(self, oldName)
self.delObjects([oldName])
newItem = None
if newName in sdict:
newItem = getattr(self, newName)
if oldItem and newItem is None:
self.setObject(newName, oldItem)
upgraderRepairAttributes = utility.upgradeLimit(upgraderRepairAttributes,
141)
security.declarePrivate('upgraderRemoveParentMCP')
def upgraderRemoveParentMCP(self):
"This removes parent facing links and links to the main compounddoc"
self.delObjects(['MCP', 'Parent'])
upgraderRemoveParentMCP = utility.upgradeLimit(upgraderRemoveParentMCP,
141)
security.declarePrivate('upgraderRemoveDuplicateObservingEntries')
def upgraderRemoveDuplicateObservingEntries(self):
"Remove the multiple entries that the previous observing code could get into"
if 'observing' in self.__dict__:
temp = list(set(self.observing))
if self.observing != temp:
self.observing = temp
upgraderRemoveDuplicateObservingEntries = utility.upgradeLimit(
upgraderRemoveDuplicateObservingEntries, 141)
security.declarePrivate('upgraderChangeObservationPath')
def upgraderChangeObservationPath(self):
"Change the observation path for items in local cdocs to be locally relative"
cdoc = self.getCompoundDoc()
if 'observing' in self.__dict__:
if [1 for i in self.observing if i[0] == '/']:
temp = [
cdoc.unrestrictedTraverse(i, None) for i in self.observing
]
temp = [i.getRelativePath(self) for i in temp if i is not None]
if self.observing != temp:
self.observing = temp
upgraderChangeObservationPath = utility.upgradeLimit(
upgraderChangeObservationPath, 141)
security.declarePrivate('upgraderRemoveManager')
def upgraderRemoveManage(self):
"remove the ManageEditForm object from all non compounddocs"
self.delObjects(self.objectIds('ManageEditForm'))
upgraderRemoveManage = utility.upgradeLimit(upgraderRemoveManage, 141)
security.declarePrivate('removeOwnerFromAttribute')
def removeOwnerFromAttributes(self):
"remove _owner from all the non CompoundDoc attributes"
if self.meta_type != 'CompoundDoc':
self.delObjects(['_owner'])
removeOwnerFromAttributes = utility.upgradeLimit(removeOwnerFromAttributes,
155)
class ListMailer(UserObject):
"ListMailer class"
security = ClassSecurityInfo()
meta_type = "ListMailer"
listName = ''
listFrom = ''
subject = ''
message = ''
footer = ''
header = ''
server = 'localhost'
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit short object"
temp = []
format = '<p>%(name)s %(form)s</p>\n'
list = [''] + [
id for id, object in self.getCompoundDoc().objectItems()
if utility.isinstance(object, SimpleList)
]
temp.append(
format % {
'name': 'To',
'form': self.option_select(list, 'listName', [self.listName])
})
temp.append(format % {
'name': 'From',
'form': self.input_text('listFrom', self.listFrom)
})
temp.append(format % {
'name': 'Subject',
'form': self.input_text('subject', self.subject)
})
temp.append(format % {
'name': 'Header',
'form': self.text_area('header', self.header)
})
temp.append(format % {
'name': 'Message',
'form': self.text_area('message', self.message)
})
temp.append(format % {
'name': 'Footer',
'form': self.text_area('footer', self.footer)
})
temp.append(format % {
'name': 'Mail Server',
'form': self.input_text('server', self.server)
})
temp.append(self.create_button("sendMail", "Send All Messages"))
return ''.join(temp)
security.declarePrivate('after_manage_edit')
def after_manage_edit(self, form):
"Call this function after the editing has been processed so that additional things can be done like caching"
if 'sendMail' in form:
self.sendAllMessages()
security.declarePrivate('sendAllMessages')
def sendAllMessages(self):
"Send all the messages we have"
listName = self.listName
if listName:
addresses = getattr(self.getCompoundDoc(), listName)
message = '%s\r\n\r\n%s\r\n\r\n%s\r\n\r\n' % (
self.header, self.message, self.footer)
message = DTML(message)
From = self.listFrom
Subject = self.subject
server = smtplib.SMTP(self.server)
msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n%s")
for address in addresses.getEntries():
message = message(self, self.REQUEST, address=address)
server.sendmail(From, address,
msg % (From, address, Subject, message))
server.quit()
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.fixFrom()
security.declarePrivate('fixFrom')
def fixFrom(self):
"fix the from attribute"
if 'from' in self.__dict__:
self.listFrom = getattr(self, 'from')
self.delObjects(['from'])
fixFrom = utility.upgradeLimit(fixFrom, 141)
class DataFilter(UserObject):
"DataFilter apply this to an a list of dicts to change how it outputs"
meta_type = "DataFilter"
security = ClassSecurityInfo()
fieldMap = None
order = None
visible = None
updateReplaceList = ('order', 'visible')
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"This is the basic search function"
return ""
security.declarePrivate('configAddition')
def configAddition(self):
"addendum to the default config screen"
temp = []
append = temp.append
if self.fieldMap is not None and self.order is not None:
fieldMapKeys = sorted(self.fieldMap.keys())
dictMap = "fieldMap.%s"
orderMap = "order.%s"
elements = [['id', 'name', 'order']]
for i in fieldMapKeys:
mappedEdit = self.input_text(dictMap % i, self.fieldMap[i])
orderEdit = self.input_float(orderMap % i, self.order[i])
elements.append([i, mappedEdit, orderEdit])
append(self.create_button('clear', 'Clear Visible Items'))
append('<br>')
append(
self.option_select(self.fieldMap.keys(), 'visible',
self.getVisible(), 1, 5))
append(self.createTable(elements))
append(self.customEdit())
return ''.join(temp)
security.declarePrivate('customEdit')
def customEdit(self):
"This is an edit piece that can be overridden by various custom editing features needed by other filters"
return ""
security.declarePrivate('before_manage_edit')
def before_manage_edit(self, form):
"process the edits"
if 'clear' in form:
self.delObjects(('visible', ))
if 'visible' in form:
del form['visible']
security.declarePrivate('getFieldMapKeys')
def getFieldMapKeys(self):
"Get the keys to the fieldMap object"
if self.fieldMap is not None:
return self.fieldMap.keys()
return []
security.declarePrivate('getVisible')
def getVisible(self):
"get the visible items"
if self.visible is not None:
return self.visible
return []
security.declarePrivate('getOrderKeys')
def getOrderKeys(self):
"Get the keys to the fieldMap object"
if self.order is not None:
return self.order.keys()
return []
security.declarePrivate('getFieldOrder')
def getFieldOrder(self):
"get the current field order"
path = self.aq_parent.getConfig('orderHeaderPath')
script = None
if path:
script = self.restrictedTraverse(path, None)
if script is not None:
return script(self.getCompoundDoc())
if self.order is not None and self.visible is not None and self.fieldMap is not None:
order = sorted((value, key) for key, value in self.order.items())
visible = set(self.visible)
fieldMap = self.fieldMap
return [(name, fieldMap[name]) for i, name in order
if name in visible]
return []
def getDataRecords(self,
order,
archive=None,
start=None,
stop=None,
header=None,
query=None,
merge=None,
sliceStart=None,
sliceStop=None,
keys=None):
"get the records in this data recorder that match these constraints"
if not order:
return
if merge is not None:
records = BTrees.OOBTree.OOBTree()
if self.records is not None:
records.update(self.records)
if self.archive is not None:
records.update(self.archive)
elif archive:
records = self.archive
else:
records = self.records
if records is None:
return
if start is None and self.startTime is not None:
startTime = self.startTime(mode='view')
if startTime:
start = startTime.earliestTime()
if stop is None and self.stopTime is not None:
stopTime = self.stopTime(mode='view')
if stopTime:
stop = stopTime.latestTime()
recordOrder, recordNames = zip(*order)
allowed = None
if query is not None:
catalog = self.getCatalog(archive)
if catalog is not None:
allowed = BTrees.OOBTree.OOSet(
(float(record.record_id) for record in catalog(query)))
if header:
yield recordNames
recordsGen = None
if allowed is None:
if sliceStart is not None and sliceStop is not None:
recordsGen = records.items(start, stop)[sliceStart:sliceStop]
else:
recordsGen = records.items(start, stop)
else: #when searching with the catalog we need to seperate the Start,Stop case from not having those bounds
#the slice case probably needs to be massively updated also
if sliceStart is not None and sliceStop is not None:
recordsGen = ((name, value) for name, value in records.items(
start, stop)[sliceStart:sliceStop] if name in allowed)
elif start is not None or stop is not None:
recordsGen = ((name, records[name])
for name in BTrees.OOBTree.intersection(
BTrees.OOBTree.OOSet(
records.keys(start, stop)), allowed))
else:
recordsGen = (
(name, records[name])
for name in BTrees.OOBTree.intersection(records, allowed))
if recordsGen is not None:
for key, record in com.db.subTransDeactivateKeyValue(
recordsGen, 100, self.getPhysicalRoot()):
data = [str(record.get(name, '')) for name in recordOrder]
if keys:
yield key, data
else:
yield data
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.removeNotUsed()
security.declarePrivate('removeNotUsed')
def removeNotUsed(self):
"remove visible, fieldMap, order if not being used"
toRemove = []
if not self.visible:
toRemove.append('visible')
if not self.fieldMap:
toRemove.append('fieldMap')
if not self.order:
toRemove.append('order')
self.delObjects(toRemove)
removeNotUsed = utility.upgradeLimit(removeNotUsed, 158)
class ListText(base.Base):
"ListText is a list of text objects"
meta_type = "ListText"
security = ClassSecurityInfo()
updateAlways = 1
data = ''
sortedList = None
listBegin = '<ul>'
listEnd = '</ul>'
addType = 'InputText'
deleteButtonText = 'Delete List Entry'
addButtonText = 'Add List Entry'
scriptChangePath = ''
allowedListTypes = ('InputText', 'TextArea', 'InputFloat',
'Date', 'File', 'InputInt', 'Money', 'Picture')
classConfig = {}
classConfig['addType'] = {'name':'Type of Objects in List', 'type':'list', 'values': allowedListTypes}
classConfig['listBegin'] = {'name':'listBegin', 'type':'string'}
classConfig['listEnd'] = {'name':'listEnd', 'type':'string'}
classConfig['scriptChangePath'] = {'name':'Path to change notification script', 'type': 'path'}
updateReplaceList = ('listBegin', 'listEnd', 'addType', 'deleteButtonText', 'addButtonText', )
configurable = ('listBegin', 'listEnd', 'addType',)
security.declarePrivate('add_delete_objects')
def add_delete_objects(self, form):
"Add new objects to the existing object"
if form.get('removeme', "") != "":
self.delListItem(form['removeme'])
if 'Add' in form:
self.addListItem()
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"This is the basic search function"
temp = []
if self.sortedList:
for i in self:
temp.append(i.PrincipiaSearchSource())
return ' '.join(temp)
security.declareProtected('View', 'view')
def view(self):
"Inline draw view"
temp = []
listBegin = self.getConfig('listBegin')
listEnd = self.getConfig('listEnd')
if self.sortedList:
temp.append(listBegin)
for i in self:
text = i.view()
if text:
temp.append('<li>%s</li>' % text)
temp.append(listEnd)
return ''.join(temp)
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit short object"
temp = ['<div class="outline">']
temp.append(self.addDeleteObjectsEdit())
if self.sortedList:
format = '<div class="outline">%s</div>'
for i in self:
temp.append(format % i.edit())
temp.append("</div>")
return ''.join(temp)
security.declarePrivate('getDeletionNames')
def getDeletionNames(self,allowableTypes):
"return the names are should be used for deletion"
if self.sortedList:
#do the count from 1 instead of 0
return [""] + range(1,len(self)+1)
return ()
security.declarePrivate('getDeleteButtonName')
def getDeleteButtonName(self,allowableTypes):
"get the text for the delete button"
return self.deleteButtonText
security.declarePrivate('getAddButtonName')
def getAddButtonName(self,allowableTypes):
"get the text for the add button"
return self.addButtonText
security.declarePrivate('restrictedUserObject')
def restrictedUserObject(self):
"Return a list of the types that are allowed to be added or deleted from this object by a user"
return [self.getConfig('addType')]
security.declarePrivate('add_delete_objects_edit')
def addDeleteObjectsEdit(self):
"This is the form elements for adding and deleting objects without the form wrapper"
return '%s %s' % (self.addObjectsEdit(autoId=1,autoType=1), self.deleteObjectsEdit())
security.declarePrivate("getAvailableListsContents")
def getAvailableListsContents(self):
"Return a list of all available list items"
if self.sortedList:
return [object.data for object in self]
return []
#List behavior stuff
security.declareProtected("Access contents information", "__getitem__")
def __getitem__(self, i):
if self.sortedList is not None:
return self.sortedList[i].__of__(self)
raise IndexError
security.declareProtected("Access contents information", "__getslice__")
def __getslice__(self, i, j):
i = max(i, 0); j = max(j, 0)
for i in self.sortedList[i:j]:
yield i.__of__(self)
security.declareProtected("Access contents information", "__iter__")
def __iter__(self):
if self.sortedList:
for i in self.sortedList:
yield i.__of__(self)
security.declareProtected("Access contents information", "__len__")
def __len__(self):
if self.sortedList:
return len(self.sortedList)
return 0
security.declareProtected('Change CompoundDoc', '__setitem__', '__guarded_setitem__')
def __setitem__(self, i, item):
if self.sortedList:
self.sortedList[i].__of__(self).populatorLoader(item)
self._p_changed = 1
__guarded_setitem__ = __setitem__
security.declareProtected('Change CompoundDoc', '__delitem__', '__guarded_delitem__')
def __delitem__(self, i):
if self.sortedList:
objectId = self.sortedList[i].getId()
self.deleteRegisteredObject(objectId, [])
del self.sortedList[i]
if not len(self.sortedList):
self.sortedList=None
self._p_changed = 1
__guarded_delitem__ = __delitem__
#For some reason through the web code can't call this method so disabling it
#security.declareProtected('Change CompoundDoc', '__setslice__')
#def __setslice__(self, i, j, other):
# i = max(i, 0); j = max(j, 0)
# if self.sortedList:
# for index in range(i,j):
# self.sortedList[index] = other[index]
#For some reason through the web code can't call this method so disabling it
#security.declareProtected('Change CompoundDoc', '__delslice__')
#def __delslice__(self, i, j):
# i = max(i, 0); j = max(j, 0)
# if self.sortedList:
# items = self.sortedList[i:j]
# del self.sortedList[i:j]
# for i in items:
# self.deleteRegisteredObject(i.getId(), [])
# if not len(self.sortedList):
# self.sortedList=None
# self._p_changed = 1
security.declareProtected('Change CompoundDoc', 'append')
def append(self, item):
if not self.sortedList:
self.sortedList = []
obj = self.createNextItem()
obj.populatorLoader(item)
self.sortedList.append(obj)
self._p_changed = 1
security.declareProtected('Change CompoundDoc', 'insert')
def insert(self, i, item):
if not self.sortedList:
self.sortedList = []
obj = self.createNextItem()
obj.populatorLoader(item)
self.sortedList.insert(i, obj)
self._p_changed = 1
security.declareProtected('Change CompoundDoc', 'pop')
def pop(self, i=-1):
if self.sortedList:
item = self[i]
del self[i]
return item
security.declareProtected('Change CompoundDoc', 'reverse')
def reverse(self):
if self.sortedList:
self.sortedList.reverse()
self._p_changed = 1
#End list behavior stuff
security.declarePrivate('createNextItem')
def createNextItem(self):
'create the next object we can use'
name = utility.cleanRegisteredId(repr(time.time()).replace('.', '_'))
self.updateRegisteredObject(name, self.getConfig('addType'))
return aq_base(getattr(self,name))
security.declarePrivate('addListItem')
def addListItem(self):
"add a new list item"
obj = self.createNextItem()
if not self.sortedList:
self.sortedList = []
self.sortedList.append(obj)
self._p_changed=1
security.declarePrivate('delListItem')
def delListItem(self, name):
"delete a list item"
try:
position = int(name)-1
del self[position]
except ValueError:
pass
security.declarePrivate("removeUnNeeded")
def removeUnNeeded(self, list, typekeep):
"Remove the UnNeeded items based on this list"
pass
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.removeListIndex()
self.cleanupNames()
self.repairSortedList()
security.declarePrivate("removeListIndex")
def removeListIndex(self):
"remove the listIndex"
if self.hasObject('listIndex'):
self.delObjects(['listIndex'])
removeListIndex = utility.upgradeLimit(removeListIndex, 141)
security.declarePrivate("cleanupNames")
def cleanupNames(self):
"clean up the names in this listtext object"
addType = self.getConfig('addType')
if not reduce(operator.add,[name.count('_') for name in self.objectIds(addType)],0):
oldobjects = []
objectItems = self.objectItems(addType)
objectItems.sort()
for name,inputtext in objectItems:
self.addListItem()
#the last element i the list is what we want
self.sortedList[-1].data = inputtext.data
oldobjects.append(name)
self.delObjects(oldobjects)
cleanupNames = utility.upgradeLimit(cleanupNames, 141)
security.declarePrivate("repairSortedList")
def repairSortedList(self):
"repair the sortedList object"
if self.sortedList and len(self.sortedList) != len(self.objectIds(self.addType)):
"sortedList is broken because it does not match the objects that should be in it regenerate it"
addType = self.getConfig('addType')
self.sortedList = [aq_base(inputtext) for inputtext in self.objectValues(addType)]
repairSortedList = utility.upgradeLimit(repairSortedList, 141)
security.declarePrivate('populatorInformation')
def populatorInformation(self):
"return a string that this metods pair can read back to load data in this object"
if self.sortedList:
return ' /-\ '.join([item.data.replace('\n','\\n') for item in self.sortedList])
return ''
security.declarePrivate('populatorLoader')
def populatorLoader(self, string):
"load the data into this object if it matches me"
items = string.split(' /-\ ')
total = 0
if self.sortedList:
total = len(self.sortedList)
if len(items) < total:
numberToDelete = total - len(items)
self.delObjects([item.getId() for item in self.sortedList[-numberToDelete:]])
self.sortedList = self.sortedList[0:-numberToDelete]
elif len(items) > total:
for i in xrange(len(items)-total):
self.addListItem()
for i in xrange(total):
self.sortedList[i].__of__(self).setObject('data',items[i].replace('\\n','\n'))
class EComControl(base.Base):
"EComControl hooks up an object for ecommerece addition/subtraction"
meta_type = "EComControl"
security = ClassSecurityInfo()
overwrite = 1
data = '<a href="%(add)s">Add</a>/<a href="%(remove)s">Remove</a>'
pathToShoppingCart = 'shoppingCart/cart'
SessionManagerConfig = None
configurable = ('data', 'pathToShoppingCart')
security.declareProtected('View', 'view')
def view(self):
"Inline draw view"
url = self.absolute_url()
return self.getConfig('data') % {
'add': url + '/add',
'remove': url + '/remove'
}
security.declarePublic('remove')
def remove(self, redirect=1, args=None, url=None):
"if we have this cdoc in the sessionmanager remove it"
path = self.getCompoundDoc().getPath()
self.getShoppingCart().removeOrder(path, args)
if redirect:
return self.redirectBackToPage(url)
security.declarePrivate('redirectBackToPage')
def redirectBackToPage(self, url=None):
"redirect back to the referring page and if we don't have one redirect back to the closest compounddoc"
url = url or self.REQUEST.get('HTTP_REFERER', None)
if url is None:
url = self.getCompoundDoc().absolute_url()
return self.REQUEST.RESPONSE.redirect(url)
security.declarePublic('add')
def add(self, redirect=1, quantity=1, args=None, url=None):
"if we don't have this cdoc in the sessionmanager add it and set it to 1"
quantity = validators.checkInt(quantity)
if quantity is None:
quantity = 1
path = self.getCompoundDoc().getPath()
self.getShoppingCart().addOrder(path, quantity, args)
if redirect:
return self.redirectBackToPage(url)
security.declarePrivate('getShoppingCart')
def getShoppingCart(self):
"return the shopping cart object"
return self.restrictedTraverse(self.getConfig('pathToShoppingCart'))
security.declareProtected('View management screens', 'edit')
def edit(self, *args, **kw):
"Inline edit view"
temp = [self.input_text('data', self.data)]
temp.append(
'<p>Where is the shopping cart located? %s</p>' %
self.input_text('pathToShoppingCart', self.pathToShoppingCart))
return ''.join(temp)
security.declarePrivate('PrincipiaSearchSource')
def PrincipiaSearchSource(self):
"Return what can be search which is nothing"
return ''
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.removeSessionManagerConfig()
security.declarePrivate('removeSessionManagerConfig')
def removeSessionManagerConfig(self):
"remove SessionManagerConfig"
self.delObjects(['SessionManagerConfig'])
removeSessionManagerConfig = utility.upgradeLimit(
removeSessionManagerConfig, 156)
class SectionText(TextArea):
"SectionText class"
meta_type = "SectionText"
security = ClassSecurityInfo()
header = '2'
heading = ''
classConfig = {}
classConfig['struct'] = {'name': 'struct', 'type': 'radio'}
classConfig['structstate'] = {
'name': 'Structured Text Enabled',
'type': 'radio'
}
classConfig['header'] = {
'name': 'header',
'type': 'list',
'values': ['1', '2', '3', '4', '5', '6']
}
classConfig['heading'] = {'name': 'heading', 'type': 'string'}
configKeep = ('structstate', 'header')
configurable = ('structstate', 'header')
security.declareProtected('View management screens', 'edit')
def edit(self, struct=None, *args, **kw):
"Inline edit short object"
temp = [
self.editSingleConfig('heading'),
self.text_area('data', self.data)
]
if struct is not None:
struct = self.struct
if struct:
format = '<div>%s Click "No" if you don\'t want your text auto-formatted.</div>'
temp.append(format % self.editSingleConfig('structstate'))
return ''.join(temp)
security.declareProtected('View', 'view')
def view(self):
"Render page"
if self.getConfig('structstate'):
return self.renderCache
else:
return self.renderCache + self.data
security.declarePrivate('updateCache')
def updateCache(self):
"update the cache of this object if applicable"
string = ''
heading = self.heading
if heading:
header = self.getConfig('header')
string = '<h%s>%s</h%s>\n' % (header, heading, header)
if self.getConfig('structstate'):
string = string + str(nocodestructured.HTML(self.data, header=0))
self.setObject('renderCache', string)
security.declarePrivate('classUpgrader')
def classUpgrader(self):
"upgrade this class"
self.upgradeStringToAttributeText()
self.removeAttributeText()
security.declarePrivate('upgradeStringToAttributeText')
def upgradeStringToAttributeText(self):
"upgrade a string header to an attributetext one"
if isinstance(self.heading, types.StringType):
self.addRegisteredObject('heading',
'AttributeText',
data=self.heading)
upgradeStringToAttributeText = utility.upgradeLimit(
upgradeStringToAttributeText, 141)
security.declarePrivate('populatorInformation')
def populatorInformation(self):
"return a string that this metods pair can read back to load data in this object"
return '%s /-\ %s' % (self.heading, self.data.replace('\n', '\\n'))
security.declarePrivate('populatorLoader')
def populatorLoader(self, string):
"load the data into this object if it matches me"
heading, data = string.split(' /-\ ', 1)
self.setObject('data', data.replace('\\n', '\n'))
self.setObject('heading', heading.replace('\\n', '\n'))
self.updateCache()
security.declarePrivate('removeAttributeText')
def removeAttributeText(self):
"remove the attributetext items and replace them with basic attributes"
heading = self.heading.data
self.delObjects(('heading', ))
self.setObject('heading', heading)
self.updateCache()
removeAttributeText = utility.upgradeLimit(removeAttributeText, 149)
security.declareProtected('Change CompoundDoc', 'store')
def store(self, data, heading):
"set the calculation value of this object"
self.setObject('data', str(data))
self.setObject('heading', str(heading))
self.updateCache()
