class Connection(DABase.Connection): """ ZCxOracle Database Adapter Connection. """ database_type = database_type id = '%s_database_connection' % database_type meta_type = title = 'Z %s Database Connection' % database_type icon = 'misc_/Z%sDA/conn' % database_type _v_connected = '' def __init__(self, id, title, connection_string, check=None): self.id = str(id) self.edit(title, connection_string, check) def factory(self): """ Base API. Returns factory method for DB connections. """ return DB def edit(self, title, connection_string, check=1): self.title = title self.connection_string = connection_string if check: self.connect(connection_string) manage_properties = Globals.HTMLFile('dtml/connectionEdit', globals())
class ZClassOwner(ExtensionClass.Base): manage_addZClassForm = Globals.HTMLFile( 'dtml/addZClass', globals(), default_class_='OFS.SimpleItem Item', CreateAFactory=1, zope_object=1) def manage_addZClass(self, id, title='', baseclasses=[], meta_type='', CreateAFactory=0, REQUEST=None, zope_object=0): "Add a ZClass" return ZClass.manage_addZClass(self, id, title, baseclasses, meta_type, CreateAFactory, REQUEST, zope_object=zope_object) manage_subclassableClassNames = manage_subclassableClassNames
class Connection(DABase.Connection): " " database_type = database_type id = '%s_database_connection' % database_type meta_type = title = 'Z %s Database Connection' % database_type icon = 'misc_/Z%sDA/conn' % database_type manage_properties = Globals.HTMLFile('dtml/connectionEdit', globals(), data_sources=data_sources) def connected(self): if hasattr(self, '_v_database_connection'): return self._v_database_connection.opened return '' def title_and_id(self): s = _Connection.inheritedAttribute('title_and_id')(self) if (hasattr(self, '_v_database_connection') and self._v_database_connection.opened): s = "%s, which is connected" % s else: s = "%s, which is <font color=red> not connected</font>" % s return s def title_or_id(self): s = _Connection.inheritedAttribute('title_and_id')(self) if (hasattr(self, '_v_database_connection') and self._v_database_connection.opened): s = "%s (connected)" % s else: s = "%s (<font color=red> not connected</font>)" % s return s def connect(self, s): _connections_lock.acquire() try: c = _connections if c.has_key(s): c = self._v_database_connection = c[s] if not c.opened: c.open() return self try: try: self._v_database_connection = c[s] = DB(s) except: t, v, tb = sys.exc_info() raise BadRequest, ( '<strong>Invalid connection string: </strong>' '<CODE>%s</CODE><br>\n' '<!--\n%s\n%s\n-->\n' % (s, t, v)), tb finally: tb = None return self finally: _connections_lock.release()
class UniqueSheet(OFS.PropertySheets.PropertySheet, OFS.PropertySheets.View): 'Manage id of unique objects' manage = Globals.HTMLFile('uniqueid', globals()) def getId(self): return self.getClassAttr('id') def manage_edit(self, id, REQUEST=None): self.setClassAttr('id', id) if REQUEST is not None: return self.manage(self, REQUEST)
self, p, title, description, email_from_address, email_from_name, validate_email, ): p._setProperty('email_from_address', email_from_address, 'string') p._setProperty('email_from_name', email_from_name, 'string') p._setProperty('validate_email', validate_email and 1 or 0, 'boolean') p.title = title p.description = description manage_addCMFSiteForm = Globals.HTMLFile('dtml/addPortal', globals()) manage_addCMFSiteForm.__name__ = 'addPortal' def manage_addCMFSite(self, id, title='Portal', description='', create_userfolder=1, email_from_address='postmaster@localhost', email_from_name='Portal Administrator', validate_email=0, RESPONSE=None): ''' Adds a portal instance. '''
self.setup(p, create_userfolder) return p def setupDefaultProperties(self, p, title, description, email_from_address, email_from_name, validate_email, ): p._setProperty('email_from_address', email_from_address, 'string') p._setProperty('email_from_name', email_from_name, 'string') p._setProperty('validate_email', validate_email and 1 or 0, 'boolean') p.title = title p.description = description manage_addZentinelPortal = Globals.HTMLFile('dtml/addPortal', globals()) manage_addZentinelPortal.__name__ = 'addPortal' def manage_addZentinelPortal(obj, id="zport", title='Zentinel Portal', description='', create_userfolder=True, email_from_address='postmaster@localhost', email_from_name='Portal Administrator', validate_email=0, RESPONSE=None): ''' Adds a portal instance. ''' gen = PortalGenerator() from string import strip id = strip(id) p = gen.create(obj, id, create_userfolder)
class Draft(Persistent, Implicit, SimpleItem.Item): "Daft objects" _refid='' _version='/version' meta_type='Zope Draft' security = ClassSecurityInfo() def __init__(self, id, baseid, PATH_INFO): self.id=id self._refid=baseid version=PATH_INFO l=version.rfind('/') if l >= 0: version=version[:l] self._version="%s/%s" % (version, id) self.users__draft__=uf=AccessControl.User.UserFolder() self.__allow_groups__=uf def icon(self): try: return getattr(self.aq_parent.aq_base,self._refid).icon except: return 'p_/broken' def manage_options(self): try: return getattr(self.aq_parent.aq_base,self._refid).manage_options except: return () def title(self): return 'draft of '+self._refid def title_and_id(self): nonempty=self.nonempty() if nonempty: return ('draft of %s (%s)' '</a> <a href="%s/users__draft__/manage_main">[Users]' '</a> <a href="%s/manage_approve__draft__">[Approve]' % (self._refid, self.id, self.id, self.id, )) else: return ('draft of %s (%s)' '</a> <a href="%s/users__draft__/manage_main">[Users]' % (self._refid, self.id, self.id, )) def __bobo_traverse__(self, REQUEST, name): if name[-9:]=='__draft__': return getattr(self, name) try: db=self._p_jar.db() except: # BoboPOS 2 jar = Globals.VersionBase[self._version].jar else: # ZODB 3 jar = db.open(self._version) cleanup = Cleanup(jar) REQUEST[Cleanup]=cleanup dself=getdraft(self, jar) ref=getattr(dself.aq_parent.aq_base,dself._refid).aq_base.__of__(dself) if hasattr(ref, name): return dself, ref, getattr(ref, name) return getattr(self, name) def nonempty(self): try: db=self._p_jar.db() except: # BoboPOS 2 return Globals.VersionBase[self._version].nonempty() else: # ZODB 3 return not db.versionEmpty(self._version) security.declareProtected('Approve draft changes', 'manage_approve__draft__') manage_approve__draft__=Globals.HTMLFile('dtml/draftApprove', globals()) security.declareProtected('Approve draft changes', 'manage_Save__draft__') def manage_Save__draft__(self, remark, REQUEST=None): """Make version changes permanent""" try: db=self._p_jar.db() except: # BoboPOS 2 Globals.VersionBase[self._version].commit(remark) else: # ZODB 3 s=self._version d=self._p_jar.getVersion() if d==s: d='' db.commitVersion(s, d) if REQUEST: REQUEST['RESPONSE'].redirect(REQUEST['URL2']+'/manage_main') security.declareProtected('Approve draft changes', 'manage_Discard__draft__') def manage_Discard__draft__(self, REQUEST=None): 'Discard changes made during the version' try: db=self._p_jar.db() except: # BoboPOS 2 Globals.VersionBase[self._version].abort() else: # ZODB 3 db.abortVersion(self._version) if REQUEST: REQUEST['RESPONSE'].redirect(REQUEST['URL2']+'/manage_main') def manage_afterClone(self, item): self._version='' def manage_afterAdd(self, item, container): if not self._version: self._version=self.absolute_url(1) def manage_beforeDelete(self, item, container): if self.nonempty(): raise ValueError, ( 'Attempt to %sdelete a non-empty version.<p>' ((self is not item) and 'indirectly ' or ''))
# This software is subject to the provisions of the Zope Public License, # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE # ############################################################################## import Globals, AccessControl.User from Globals import Persistent from Globals import InitializeClass from AccessControl import ClassSecurityInfo from Acquisition import Implicit from OFS import SimpleItem manage_addPrincipiaDraftForm=Globals.HTMLFile('dtml/draftAdd',globals()) def manage_addPrincipiaDraft(self, id, baseid, PATH_INFO, REQUEST=None): "Add a draft object" self._setObject(id, Draft(id, baseid, PATH_INFO)) if REQUEST is not None: return self.manage_main(self,REQUEST) class Draft(Persistent, Implicit, SimpleItem.Item): "Daft objects" _refid='' _version='/version' meta_type='Zope Draft' security = ClassSecurityInfo() def __init__(self, id, baseid, PATH_INFO): self.id=id
$Id$''' % database_type __version__ = '$Revision: 1.16 $'[11:-2] from db import DB, manage_DataSources import sys, DABase, Globals import Shared.DC.ZRDB.Connection, ThreadLock from zExceptions import BadRequest _Connection = Shared.DC.ZRDB.Connection.Connection _connections = {} _connections_lock = ThreadLock.allocate_lock() data_sources = manage_DataSources addConnectionForm = Globals.HTMLFile('dtml/connectionAdd', globals()) def manage_addZGadflyConnection(self, id, title, connection, check=None, REQUEST=None): """Add a DB connection to a folder""" # Note - type checking is taken care of by _setObject # and the Connection object constructor. self._setObject(id, Connection(id, title, connection, check)) if REQUEST is not None: return self.manage_main(self, REQUEST)
class ZClassMethodsSheet(OFS.PropertySheets.PropertySheet, OFS.PropertySheets.View, OFS.Folder.Folder, App.ProductRegistry.ProductRegistryMixin, ZClassOwner.ZClassOwner): "Manage instance methods" id = 'contents' icon = 'p_/Methods_icon' def tpURL(self): return 'propertysheets/methods' ###################################################################### # Hijinks to let us create factories and classes within classes. meta_types = ( { 'name': 'Z Class', 'action': 'manage_addZClassForm' }, { 'name': App.Factory.Factory.meta_type, 'action': 'manage_addPrincipiaFactoryForm' }, { 'name': 'Property Sheet Interface', 'action': 'manage_addPropertyInterfaceForm' }, ) def manage_addPrincipiaFactory(self, id, title, object_type, initial, permission=None, REQUEST=None): ' ' i = App.Factory.Factory(id, title, object_type, initial, permission) self._setObject(id, i) factory = self._getOb(id) factory.initializePermission() if REQUEST is not None: return self.manage_main(self, REQUEST, update_menu=1) def _getProductRegistryMetaTypes(self): return self.getClassAttr('_zclass_method_meta_types', ()) def _setProductRegistryMetaTypes(self, v): return self.setClassAttr('_zclass_method_meta_types', v) def _constructor_prefix_string(self, pid): return '' ###################################################################### manage_addPropertyInterfaceForm = Globals.HTMLFile( 'dtml/addPropertyInterface', globals()) # This is to trigger alternate access management for methods: _isBeingUsedAsAMethod_ = 1 def _isBeingUsedAsAMethod(self, REQUEST=None, wannaBe=0): if REQUEST is not None and wannaBe: REQUEST.response.notFoundError() return 0 def permissionMappingPossibleValues(self): return self.classDefinedAndInheritedPermissions() def meta_type(self): return self.aq_inner.aq_parent.aq_parent.meta_type def manage(self, REQUEST): " " return self.manage_main(self, REQUEST) def manage_addDTMLMethod(self, id, title='', file='', REQUEST=None, submit=None): "Add a DTML Method using a management template" if not file: file = default_dm_html return ZClassMethodsSheet.inheritedAttribute('manage_addDTMLMethod')( self, id, title, file, REQUEST, submit) def _checkId(self, id, allow_dup=0, _reserved=('propertysheets', 'manage_workspace')): if id in _reserved: raise BadRequest, 'The id, %s, is reserved' % escape(id) if not allow_dup and self.getClassAttr(id, self) is not self: raise BadRequest, ('The id %s is invalid - it is already in use.' % escape(id)) ZClassMethodsSheet.inheritedAttribute('_checkId')(self, id, 1) return id + ' ' def _setOb(self, id, object): self.setClassAttr(id.strip(), MWp(object)) def _delOb(self, id): self.delClassAttr(id.strip()) def _delObject(self, id, dp=1): # Ick! This is necessary to deal with spaces. Waaa! object = self._getOb(id) object.manage_beforeDelete(object, self) id = id.strip() self._objects = tuple( filter(lambda i, n=id: i['id'].strip() != n, self._objects)) self._delOb(id) def _getOb(self, id, default=_marker): if default is _marker: r = self.getClassAttr(id.strip()) else: try: r = self.getClassAttr(id.strip()) except: return default if hasattr(r, methodattr): m = r.__dict__[methodattr] if r.__class__ is W: # Ugh, we need to convert an old wrapper to a new one wrapper = getattr(m, '_permissionMapper', None) if wrapper is None: wrapper = PermissionMapper() for k, v in r.__dict__.items(): if k[:1] == '_' and k[-11:] == '_Permission': setattr(wrapper, k, v) m._permissionMapper = wrapper mw = MWp(m) self.setClassAttr(id.strip(), mw) r = m return getattr(r, 'aq_base', r).__of__(self) def __bobo_traverse__(self, request, name): if hasattr(self, 'aq_base'): b = self.aq_base if hasattr(b, name): return getattr(self, name) try: return self[name] except: return getattr(self, name) def possible_permissions(self): return self.classDefinedAndInheritedPermissions() # # FTP support # def manage_FTPstat(self, REQUEST): "Psuedo stat used for FTP listings" mode = 0040000 | 0770 mtime = self.bobobase_modification_time().timeTime() owner = group = 'Zope' return marshal.dumps( (mode, 0, 0, 1, owner, group, 0, mtime, mtime, mtime)) def PUT_factory(self, name, typ, body): """ Hook PUT creation to make objects of the right type when new item uploaded via FTP/WebDAV. """ if typ is None: typ, enc = guess_content_type() if typ == 'text/x-python': return PythonScript(name) if typ[:4] == 'text': return DTMLMethod('', __name__=name) return None # take the default, then
class ErrorTranslator(Folder.Folder, Persistence.Persistent, Acquisition.Implicit, AccessControl.Role.RoleManager): __implements__ = IErrorTranslator.IErrorTranslator security = AccessControl.ClassSecurityInfo() id = 'ErrorTranslator' title = "Error Translation registry" meta_type = "Error Translator" security.declareProtected('View management screens', 'manage_debug') manage_debug = Globals.HTMLFile('dtml/ErrorTranslatorDebug', globals()) manage_options = Folder.Folder.manage_options + \ ( {'label':'Debug', 'action':'manage_debug'}, ) manage_options = filter(lambda x: x['label'] not in ['View', 'Properties', 'Find'], manage_options) ##### Here comes the ZOPE management stuff def __init__(self): self.__version__ = __version__ def all_meta_types(self): """We only want to add Error Translation Rules here.""" allowedMetaTypes = ["Error Translation Rule", "Error Translation Rule Group"] result = [] import Products for metaType in Products.meta_types: if metaType['name'] in allowedMetaTypes: result.append(metaType) return result security.declarePublic("translateEasy") def translateEasy(self, type=None, value=None, description=None): """ Try a translation when we only got a type and a value. """ hint = ErrorTranslationHint(None, None, type, value, None, description) translated = self.translate(hint) return translated security.declarePublic("translate") def translate(self, error): """Translate the given error. error: ErrorTranslationHint returns: ErrorTranslationHint instance This means the hint will be set to a value useful for the user. The actual work is done by the rules. We only try to find the actual rule that matches this error. Then the rule has to do the work. """ assert IErrorTranslator.IErrorTranslationHint.isImplementedBy(error), \ "ErrorTranslator interface not satisfied" rules = self.discoverRules() is_translated = 0 for rule in rules: if (IErrorTranslator.IErrorTranslationRule.isImplementedBy(rule) and rule.isResponsible(error)): rule.translate(error) is_translated = 1 break if not is_translated and not error.field: zLOG.LOG('ErrorTranslator', zLOG.INFO, 'Untranslated exception occured', str(error)) error.field = ERROR_FIELD_BLANK error.description = error.hint return error security.declarePrivate('discoverRules') def discoverRules(self): stack = self.objectValues() rules = [] while stack: element = stack.pop() # Append rule to the list if isinstance(element, ErrorTranslationRule): rules.append(element) # Check if it could be a container that holds more rules try: new = element.objectValues() stack.extend(new) except AttributeError: pass rules.sort(lambda x,y: cmp(x.getPriority(), y.getPriority())) return rules
class ErrorTranslationRule(SimpleItem.SimpleItem): __implements__ = IErrorTranslator.IErrorTranslationRule security = AccessControl.ClassSecurityInfo() meta_type = "Error Translation Rule" manage_properties = Globals.HTMLFile('dtml/ErrorTranslationRuleEdit', globals()) title = "" # Regexp to match the error type typeMatch = None # Regexp to match the error value errorMatch = None # Regexp with backreferences to errorMatch for creating the user message msgRule = None # Number of group in errorMatch for the Fielis dname # SPECIAL CASE: if no number, you can write the fieldname in here # (or its alias) brField = None # Number of group in errorMatch for the Value brValue = None # Priority for sorting the rules (0 = lowest, >0 = higher Priority) priority = 100 manage_options = ( {'label':'Properties', 'action':'manage_properties'}, ) # Here comes the Zope specific code def __init__(self, id, REQUEST=None): self.id = id if REQUEST is not None: self.update(REQUEST) security.declareProtected("Change Translation Rules", "manage_edit") def manage_edit(self, REQUEST=None): """ZMI data save method""" if REQUEST is not None: self.update(REQUEST) return Globals.MessageDialog(title="Edited", message="Properties for %s changed." % self.id, action="./manage_properties") security.declareProtected("Change Translation Rules", "update") def update(self, REQUEST): if REQUEST is None: return self.title = REQUEST.title self.typeMatch = REQUEST.typeMatch self.errorMatch = REQUEST.errorMatch self.msgRule = unicode(REQUEST.msgRule, 'iso-8859-1') self.brField = REQUEST.brField or None try: self.brValue = int(REQUEST.brValue) except ValueError: self.brValue = None self.priority = REQUEST.priority def re_typeMatch(self): return re.compile(self.typeMatch, re.MULTILINE + re.DOTALL) re_typeMatch = zope.cachedescriptors.property.CachedProperty( re_typeMatch, 'typeMatch') def re_errorMatch(self): return re.compile(self.errorMatch, re.MULTILINE + re.DOTALL) re_errorMatch = zope.cachedescriptors.property.CachedProperty( re_errorMatch, 'errorMatch') security.declarePublic("isResponsible") def isResponsible(self, error): """returns whether this rule can translate given error error: uhm.. what is error? XXX returns True if rule would be appropriate to use for the translation, False otherwise """ if self.re_typeMatch.search(unicode(error.errortype)) is None: return False if self.re_errorMatch.search(unicode(error.hint)) is None: return False return True security.declarePublic("translate") def translate(self, error): if not self.isResponsible(error): raise ResponsibilityError, "%s is not responsible for this error." % self.id # XXX check for IErrorTranslationHint here brFieldString = '' try: brFieldNo = int(self.brField) except (TypeError, ValueError): brFieldNo = 0 brFieldString = self.brField match = self.re_errorMatch.search(unicode(error.hint)) groups = match.groups() # If the groupcount from the regexp doesn't match, # we don't check for a regexp translation. # XXX probably a debugging note on the server would # be appropriate here. regex_value = (self.brValue <= len(groups)) and self.brValue regex_field = (brFieldNo <= len(groups)) and brFieldNo # Find the Fieldname: if error.field: # The error already knew it's field pass elif regex_field: # We knew how to handle it with a reg. exp. error.field = groups[regex_field-1] elif brFieldString: error.field = brFieldString else: # We need to find the field by Value. if error.value: pass elif regex_value: error.value = groups[regex_value-1] # try to find a field matching the fieldname or alias of the error if error.field is not None and error.form is not None: field_translated = None for item in error.form.objectValues(): if not IWidget.IWidget.isImplementedBy(item): continue if not item.testCondition(): # do not show errors on hidden fields continue name_candidates = (tuple(item.getAliases()) + tuple([item.getName()]) ) if error.field in name_candidates : field_translated = item.getName() break if field_translated: error.field = field_translated else: error.field = ERROR_FIELD_BLANK # Fieldname not existing in form elif error.value is None: error.field = ERROR_FIELD_BLANK # try to find a field matching the fieldvalue if (error.field is None and error.value is not None and error.form is not None): candidate = None for item in error.form.objectValues(): if IWidget.IWidget.isImplementedBy(item) and \ error.value == item.getValue() and not candidate: candidate = item.getName() error.field = candidate # create the translated error message if not error.description: error.description = self.re_errorMatch.sub(self.msgRule, error.hint, 1) security.declareProtected("Access contents information", "getPriority") def getPriority(self): return self.priority
rules.append(element) # Check if it could be a container that holds more rules try: new = element.objectValues() stack.extend(new) except AttributeError: pass rules.sort(lambda x,y: cmp(x.getPriority(), y.getPriority())) return rules Globals.InitializeClass(ErrorTranslator) manage_addErrorTranslationRule = Globals.HTMLFile('dtml/ErrorTranslationRuleAdd', globals()) def createErrorTranslationRule(context, id, REQUEST=None): """A factory for creating a new translation rule.""" context._setObject(id, ErrorTranslationRule(id, REQUEST)) if REQUEST is not None: return context.manage_main(context, REQUEST) class ErrorTranslationRule(SimpleItem.SimpleItem): __implements__ = IErrorTranslator.IErrorTranslationRule security = AccessControl.ClassSecurityInfo() meta_type = "Error Translation Rule" manage_properties = Globals.HTMLFile('dtml/ErrorTranslationRuleEdit', globals())
database_type = 'CxOracle' from App.ImageFile import ImageFile from App.special_dtml import DTMLFile import os import os.path from db import DB from thread import allocate_lock from Shared.DC import ZRDB import DABase import Shared.DC.ZRDB.Connection import Globals manage_addZCxOracleConnectionForm = Globals.HTMLFile('dtml/connectionAdd', globals()) def manage_addZCxOracleConnection(self, id, title, connection_string, check=None, REQUEST=None): """Add a DB connection to a folder""" self._setObject(id, Connection(id, title, connection_string, check)) if REQUEST is not None: return self.manage_main(self, REQUEST) _Connection = Shared.DC.ZRDB.Connection.Connection