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
