2009-06-29 07:06:01 -05:00
|
|
|
'''This package contains base classes for wrappers that hide to the Appy
|
2009-09-18 07:42:31 -05:00
|
|
|
developer the real classes used by the underlying web framework.'''
|
2009-06-29 07:06:01 -05:00
|
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
2010-03-25 10:34:37 -05:00
|
|
|
import os, os.path, time, mimetypes, random
|
2009-12-17 14:14:52 -06:00
|
|
|
import appy.pod
|
2009-11-06 04:33:56 -06:00
|
|
|
from appy.gen import Search
|
2010-11-26 10:30:46 -06:00
|
|
|
from appy.gen.utils import sequenceTypes
|
2010-03-25 10:34:37 -05:00
|
|
|
from appy.shared.utils import getOsTempFolder, executeCommand, normalizeString
|
2009-11-11 13:22:13 -06:00
|
|
|
from appy.shared.xml_parser import XmlMarshaller
|
2009-07-10 08:01:50 -05:00
|
|
|
|
|
|
|
# Some error messages ----------------------------------------------------------
|
|
|
|
WRONG_FILE_TUPLE = 'This is not the way to set a file. You can specify a ' \
|
|
|
|
'2-tuple (fileName, fileContent) or a 3-tuple (fileName, fileContent, ' \
|
|
|
|
'mimeType).'
|
2009-06-29 07:06:01 -05:00
|
|
|
|
|
|
|
# ------------------------------------------------------------------------------
|
|
|
|
class AbstractWrapper:
|
|
|
|
'''Any real web framework object has a companion object that is an instance
|
|
|
|
of this class.'''
|
2010-11-26 10:30:46 -06:00
|
|
|
def __init__(self, o): self.__dict__['o'] = o
|
|
|
|
|
|
|
|
def __setattr__(self, name, value):
|
2009-07-10 08:01:50 -05:00
|
|
|
appyType = self.o.getAppyType(name)
|
2010-08-05 11:23:17 -05:00
|
|
|
if not appyType:
|
2009-07-10 08:01:50 -05:00
|
|
|
raise 'Attribute "%s" does not exist.' % name
|
2010-11-26 10:30:46 -06:00
|
|
|
appyType.store(self.o, value)
|
|
|
|
|
2009-11-11 13:22:13 -06:00
|
|
|
def __repr__(self):
|
2010-11-26 10:30:46 -06:00
|
|
|
return '<%s appyobj at %s>' % (self.klass.__name__, id(self))
|
|
|
|
|
2009-06-29 07:06:01 -05:00
|
|
|
def __cmp__(self, other):
|
2009-10-27 08:48:04 -05:00
|
|
|
if other: return cmp(self.o, other.o)
|
2010-11-26 10:30:46 -06:00
|
|
|
else: return 1
|
|
|
|
|
2011-01-14 02:06:25 -06:00
|
|
|
def _callCustom(self, methodName, *args, **kwargs):
|
|
|
|
'''This wrapper implements some methods like "validate" and "onEdit".
|
|
|
|
If the user has defined its own wrapper, its methods will not be
|
|
|
|
called. So this method allows, from the methods here, to call the
|
|
|
|
user versions.'''
|
|
|
|
if len(self.__class__.__bases__) > 1:
|
|
|
|
# There is a custom user class
|
|
|
|
customUser = self.__class__.__bases__[-1]
|
|
|
|
if customUser.__dict__.has_key(methodName):
|
|
|
|
customUser.__dict__[methodName](self, *args, **kwargs)
|
|
|
|
|
2009-10-27 08:48:04 -05:00
|
|
|
def get_tool(self): return self.o.getTool().appy()
|
2009-06-29 07:06:01 -05:00
|
|
|
tool = property(get_tool)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2009-11-06 04:33:56 -06:00
|
|
|
def get_request(self): return self.o.REQUEST
|
|
|
|
request = property(get_request)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2009-10-27 08:48:04 -05:00
|
|
|
def get_session(self): return self.o.REQUEST.SESSION
|
2009-06-29 07:06:01 -05:00
|
|
|
session = property(get_session)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2009-10-27 08:48:04 -05:00
|
|
|
def get_typeName(self): return self.__class__.__bases__[-1].__name__
|
2009-06-29 07:06:01 -05:00
|
|
|
typeName = property(get_typeName)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2009-10-27 08:48:04 -05:00
|
|
|
def get_id(self): return self.o.id
|
2009-06-29 07:06:01 -05:00
|
|
|
id = property(get_id)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2010-11-22 02:36:14 -06:00
|
|
|
def get_uid(self): return self.o.UID()
|
|
|
|
uid = property(get_uid)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2009-06-29 07:06:01 -05:00
|
|
|
def get_state(self):
|
|
|
|
return self.o.portal_workflow.getInfoFor(self.o, 'review_state')
|
|
|
|
state = property(get_state)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2009-06-29 07:06:01 -05:00
|
|
|
def get_stateLabel(self):
|
|
|
|
appName = self.o.getProductConfig().PROJECTNAME
|
2010-11-26 10:30:46 -06:00
|
|
|
return self.o.translate(self.o.getWorkflowLabel(), domain=appName)
|
2009-06-29 07:06:01 -05:00
|
|
|
stateLabel = property(get_stateLabel)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2010-08-05 11:23:17 -05:00
|
|
|
def get_klass(self): return self.__class__.__bases__[-1]
|
2009-06-29 07:06:01 -05:00
|
|
|
klass = property(get_klass)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2010-08-05 11:23:17 -05:00
|
|
|
def get_url(self): return self.o.absolute_url()
|
2009-11-06 04:33:56 -06:00
|
|
|
url = property(get_url)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2009-11-24 15:41:42 -06:00
|
|
|
def get_history(self):
|
|
|
|
key = self.o.workflow_history.keys()[0]
|
|
|
|
return self.o.workflow_history[key]
|
|
|
|
history = property(get_history)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2010-08-05 11:23:17 -05:00
|
|
|
def get_user(self): return self.o.portal_membership.getAuthenticatedMember()
|
2009-12-21 13:45:29 -06:00
|
|
|
user = property(get_user)
|
2010-11-26 10:30:46 -06:00
|
|
|
|
2010-08-05 11:23:17 -05:00
|
|
|
def get_fields(self): return self.o.getAllAppyTypes()
|
|
|
|
fields = property(get_fields)
|
2009-06-29 07:06:01 -05:00
|
|
|
|
|
|
|
def link(self, fieldName, obj):
|
|
|
|
'''This method links p_obj to this one through reference field
|
2010-10-29 07:36:36 -05:00
|
|
|
p_fieldName. p_obj can also be a list or tuple of objects.'''
|
2009-06-29 07:06:01 -05:00
|
|
|
postfix = 'et%s%s' % (fieldName[0].upper(), fieldName[1:])
|
|
|
|
# Update the Archetypes reference field
|
|
|
|
exec 'objs = self.o.g%s()' % postfix
|
|
|
|
if not objs:
|
|
|
|
objs = []
|
2010-10-29 07:36:36 -05:00
|
|
|
elif type(objs) not in sequenceTypes:
|
2009-06-29 07:06:01 -05:00
|
|
|
objs = [objs]
|
2010-10-29 07:36:36 -05:00
|
|
|
# Add p_obj to the existing objects
|
|
|
|
if type(obj) in sequenceTypes:
|
|
|
|
for o in obj: objs.append(o.o)
|
|
|
|
else:
|
|
|
|
objs.append(obj.o)
|
2009-06-29 07:06:01 -05:00
|
|
|
exec 'self.o.s%s(objs)' % postfix
|
|
|
|
# Update the ordered list of references
|
2010-10-29 07:36:36 -05:00
|
|
|
sorted = self.o._appy_getSortedField(fieldName)
|
|
|
|
if type(obj) in sequenceTypes:
|
|
|
|
for o in obj: sorted.append(o.o.UID())
|
|
|
|
else:
|
|
|
|
sorted.append(obj.o.UID())
|
2009-06-29 07:06:01 -05:00
|
|
|
|
2010-04-30 05:05:29 -05:00
|
|
|
def sort(self, fieldName, sortKey='title', reverse=False):
|
|
|
|
'''Sorts referred elements linked to p_self via p_fieldName according
|
|
|
|
to a given p_sortKey which must be an attribute set on referred
|
|
|
|
objects ("title", by default).'''
|
2009-10-27 08:48:04 -05:00
|
|
|
sortedUids = getattr(self.o, '_appy_%s' % fieldName)
|
|
|
|
c = self.o.uid_catalog
|
|
|
|
sortedUids.sort(lambda x,y: \
|
2010-04-30 05:05:29 -05:00
|
|
|
cmp(getattr(c(UID=x)[0].getObject().appy(), sortKey),
|
|
|
|
getattr(c(UID=y)[0].getObject().appy(), sortKey)))
|
|
|
|
if reverse:
|
|
|
|
sortedUids.reverse()
|
2009-10-27 08:48:04 -05:00
|
|
|
|
2009-07-10 08:01:50 -05:00
|
|
|
def create(self, fieldNameOrClass, **kwargs):
|
|
|
|
'''If p_fieldNameOfClass is the name of a field, this method allows to
|
|
|
|
create an object and link it to the current one (self) through
|
|
|
|
reference field named p_fieldName.
|
|
|
|
If p_fieldNameOrClass is a class from the gen-application, it must
|
|
|
|
correspond to a root class and this method allows to create a
|
|
|
|
root object in the application folder.'''
|
|
|
|
isField = isinstance(fieldNameOrClass, basestring)
|
|
|
|
# Determine the portal type of the object to create
|
|
|
|
if isField:
|
2010-09-02 09:16:08 -05:00
|
|
|
fieldName = idPrefix = fieldNameOrClass
|
|
|
|
appyType = self.o.getAppyType(fieldName)
|
|
|
|
portalType = self.tool.o.getPortalType(appyType.klass)
|
2009-07-10 08:01:50 -05:00
|
|
|
else:
|
2010-09-02 09:16:08 -05:00
|
|
|
klass = fieldNameOrClass
|
|
|
|
idPrefix = klass.__name__
|
|
|
|
portalType = self.tool.o.getPortalType(klass)
|
2009-07-10 08:01:50 -05:00
|
|
|
# Determine object id
|
2009-06-29 07:06:01 -05:00
|
|
|
if kwargs.has_key('id'):
|
|
|
|
objId = kwargs['id']
|
|
|
|
del kwargs['id']
|
|
|
|
else:
|
2009-12-14 13:22:55 -06:00
|
|
|
objId = '%s.%f.%s' % (idPrefix, time.time(),
|
|
|
|
str(random.random()).split('.')[1])
|
2009-10-25 15:42:08 -05:00
|
|
|
# Determine if object must be created from external data
|
|
|
|
externalData = None
|
|
|
|
if kwargs.has_key('_data'):
|
|
|
|
externalData = kwargs['_data']
|
|
|
|
del kwargs['_data']
|
2009-07-10 08:01:50 -05:00
|
|
|
# Where must I create the object?
|
|
|
|
if not isField:
|
|
|
|
folder = self.o.getTool().getAppFolder()
|
2009-06-29 07:06:01 -05:00
|
|
|
else:
|
2009-07-10 08:01:50 -05:00
|
|
|
if hasattr(self, 'folder') and self.folder:
|
|
|
|
folder = self.o
|
|
|
|
else:
|
|
|
|
folder = self.o.getParentNode()
|
2009-06-29 07:06:01 -05:00
|
|
|
# Create the object
|
|
|
|
folder.invokeFactory(portalType, objId)
|
|
|
|
ploneObj = getattr(folder, objId)
|
2010-02-08 01:53:30 -06:00
|
|
|
appyObj = ploneObj.appy()
|
2009-06-29 07:06:01 -05:00
|
|
|
# Set object attributes
|
|
|
|
for attrName, attrValue in kwargs.iteritems():
|
|
|
|
if isinstance(attrValue, AbstractWrapper):
|
|
|
|
try:
|
|
|
|
refAppyType = getattr(appyObj.__class__.__bases__[-1],
|
|
|
|
attrName)
|
|
|
|
appyObj.link(attrName, attrValue.o)
|
|
|
|
except AttributeError, ae:
|
|
|
|
pass
|
|
|
|
else:
|
2010-08-05 11:23:17 -05:00
|
|
|
setattr(appyObj, attrName, attrValue)
|
2009-07-10 08:01:50 -05:00
|
|
|
if isField:
|
|
|
|
# Link the object to this one
|
|
|
|
self.link(fieldName, ploneObj)
|
|
|
|
self.o.reindexObject()
|
|
|
|
# Call custom initialization
|
2009-11-20 13:17:06 -06:00
|
|
|
if externalData: param = externalData
|
|
|
|
else: param = True
|
|
|
|
if hasattr(appyObj, 'onEdit'): appyObj.onEdit(param)
|
2009-06-29 07:06:01 -05:00
|
|
|
ploneObj.reindexObject()
|
|
|
|
return appyObj
|
|
|
|
|
2010-11-26 10:30:46 -06:00
|
|
|
def delete(self):
|
|
|
|
'''Deletes myself.'''
|
|
|
|
self.o.delete()
|
|
|
|
|
2010-10-14 07:43:56 -05:00
|
|
|
def translate(self, label, mapping={}, domain=None, language=None):
|
2009-10-18 07:52:27 -05:00
|
|
|
'''Check documentation of self.o.translate.'''
|
2010-10-14 07:43:56 -05:00
|
|
|
return self.o.translate(label, mapping, domain, language=language)
|
2009-06-29 07:06:01 -05:00
|
|
|
|
2009-11-20 13:17:06 -06:00
|
|
|
def do(self, transition, comment='', doAction=False, doNotify=False,
|
|
|
|
doHistory=True):
|
2009-06-29 07:06:01 -05:00
|
|
|
'''This method allows to trigger on p_self a workflow p_transition
|
|
|
|
programmatically. If p_doAction is False, the action that must
|
|
|
|
normally be executed after the transition has been triggered will
|
|
|
|
not be executed. If p_doNotify is False, the notifications
|
|
|
|
(email,...) that must normally be launched after the transition has
|
2009-11-20 13:17:06 -06:00
|
|
|
been triggered will not be launched. If p_doHistory is False, there
|
|
|
|
will be no trace from this transition triggering in the workflow
|
|
|
|
history.'''
|
2009-06-29 07:06:01 -05:00
|
|
|
wfTool = self.o.portal_workflow
|
|
|
|
availableTransitions = [t['id'] for t in \
|
|
|
|
wfTool.getTransitionsFor(self.o)]
|
|
|
|
transitionName = transition
|
|
|
|
if not transitionName in availableTransitions:
|
|
|
|
# Maybe is is a compound Appy transition. Try to find the
|
|
|
|
# corresponding DC transition.
|
|
|
|
state = self.state
|
|
|
|
transitionPrefix = transition + state[0].upper() + state[1:] + 'To'
|
|
|
|
for at in availableTransitions:
|
|
|
|
if at.startswith(transitionPrefix):
|
|
|
|
transitionName = at
|
|
|
|
break
|
|
|
|
# Set in a versatile attribute details about what to execute or not
|
|
|
|
# (actions, notifications) after the transition has been executed by DC
|
|
|
|
# workflow.
|
2010-11-22 02:36:14 -06:00
|
|
|
self.o._v_appy_do = {'doAction': doAction, 'doNotify': doNotify,
|
|
|
|
'doSay': False}
|
2009-11-20 13:17:06 -06:00
|
|
|
if not doHistory:
|
|
|
|
comment = '_invisible_' # Will not be displayed.
|
|
|
|
# At first sight, I wanted to remove the entry from
|
|
|
|
# self.o.workflow_history. But Plone determines the state of an
|
|
|
|
# object by consulting the target state of the last transition in
|
|
|
|
# this workflow_history.
|
2009-06-29 07:06:01 -05:00
|
|
|
wfTool.doActionFor(self.o, transitionName, comment=comment)
|
|
|
|
del self.o._v_appy_do
|
2009-07-10 08:01:50 -05:00
|
|
|
|
2009-12-17 14:14:52 -06:00
|
|
|
def log(self, message, type='info'):
|
2009-10-25 15:42:08 -05:00
|
|
|
'''Logs a message in the log file. p_logLevel may be "info", "warning"
|
|
|
|
or "error".'''
|
|
|
|
logger = self.o.getProductConfig().logger
|
2009-12-17 14:14:52 -06:00
|
|
|
if type == 'warning': logMethod = logger.warn
|
|
|
|
elif type == 'error': logMethod = logger.error
|
2009-10-25 15:42:08 -05:00
|
|
|
else: logMethod = logger.info
|
|
|
|
logMethod(message)
|
|
|
|
|
2009-12-17 14:14:52 -06:00
|
|
|
def say(self, message, type='info'):
|
|
|
|
'''Prints a message in the user interface. p_logLevel may be "info",
|
|
|
|
"warning" or "error".'''
|
|
|
|
mType = type
|
|
|
|
if mType == 'warning': mType = 'warn'
|
|
|
|
elif mType == 'error': mType = 'stop'
|
|
|
|
self.o.plone_utils.addPortalMessage(message, type=mType)
|
|
|
|
|
2010-02-12 03:59:42 -06:00
|
|
|
unwantedChars = ('\\', '/', ':', '*', '?', '"', '<', '>', '|', ' ')
|
|
|
|
def normalize(self, s, usage='fileName'):
|
2009-11-06 04:33:56 -06:00
|
|
|
'''Returns a version of string p_s whose special chars have been
|
|
|
|
replaced with normal chars.'''
|
2010-03-25 10:34:37 -05:00
|
|
|
return normalizeString(s, usage)
|
2009-11-06 04:33:56 -06:00
|
|
|
|
2010-02-22 08:28:20 -06:00
|
|
|
def search(self, klass, sortBy='', maxResults=None, noSecurity=False,
|
|
|
|
**fields):
|
2009-11-06 04:33:56 -06:00
|
|
|
'''Searches objects of p_klass. p_sortBy must be the name of an indexed
|
|
|
|
field (declared with indexed=True); every param in p_fields must
|
|
|
|
take the name of an indexed field and take a possible value of this
|
2009-11-24 15:41:42 -06:00
|
|
|
field. You can optionally specify a maximum number of results in
|
2010-01-12 14:15:14 -06:00
|
|
|
p_maxResults. If p_noSecurity is specified, you get all objects,
|
|
|
|
even if the logged user does not have the permission to view it.'''
|
2009-11-06 04:33:56 -06:00
|
|
|
# Find the content type corresponding to p_klass
|
2010-10-14 07:43:56 -05:00
|
|
|
contentType = self.tool.o.getPortalType(klass)
|
2009-11-06 04:33:56 -06:00
|
|
|
# Create the Search object
|
|
|
|
search = Search('customSearch', sortBy=sortBy, **fields)
|
2009-12-21 13:45:29 -06:00
|
|
|
if not maxResults:
|
|
|
|
maxResults = 'NO_LIMIT'
|
|
|
|
# If I let maxResults=None, only a subset of the results will be
|
|
|
|
# returned by method executeResult.
|
2010-10-14 07:43:56 -05:00
|
|
|
res = self.tool.o.executeQuery(contentType, search=search,
|
|
|
|
maxResults=maxResults, noSecurity=noSecurity)
|
2009-11-06 04:33:56 -06:00
|
|
|
return [o.appy() for o in res['objects']]
|
|
|
|
|
2010-01-14 10:54:18 -06:00
|
|
|
def count(self, klass, noSecurity=False, **fields):
|
2009-11-24 15:41:42 -06:00
|
|
|
'''Identical to m_search above, but returns the number of objects that
|
|
|
|
match the search instead of returning the objects themselves. Use
|
|
|
|
this method instead of writing len(self.search(...)).'''
|
2010-10-14 07:43:56 -05:00
|
|
|
contentType = self.tool.o.getPortalType(klass)
|
2009-11-24 15:41:42 -06:00
|
|
|
search = Search('customSearch', **fields)
|
2010-10-14 07:43:56 -05:00
|
|
|
res = self.tool.o.executeQuery(contentType, search=search,
|
|
|
|
brainsOnly=True, noSecurity=noSecurity)
|
2009-11-24 15:41:42 -06:00
|
|
|
if res: return res._len # It is a LazyMap instance
|
|
|
|
else: return 0
|
|
|
|
|
2010-02-22 08:28:20 -06:00
|
|
|
def compute(self, klass, sortBy='', maxResults=None, context=None,
|
|
|
|
expression=None, noSecurity=False, **fields):
|
2010-01-18 08:12:22 -06:00
|
|
|
'''This method, like m_search and m_count above, performs a query on
|
|
|
|
objects of p_klass. But in this case, instead of returning a list of
|
|
|
|
matching objects (like m_search) or counting elements (like p_count),
|
|
|
|
it evaluates, on every matching object, a Python p_expression (which
|
|
|
|
may be an expression or a statement), and returns, if needed, a
|
|
|
|
result. The result may be initialized through parameter p_context.
|
|
|
|
p_expression is evaluated with 2 variables in its context: "obj"
|
|
|
|
which is the currently walked object, instance of p_klass, and "ctx",
|
|
|
|
which is the context as initialized (or not) by p_context. p_context
|
|
|
|
may be used as
|
2010-02-22 08:28:20 -06:00
|
|
|
(1) a variable or instance that is updated on every call to
|
|
|
|
produce a result;
|
|
|
|
(2) an input variable or instance;
|
2010-01-18 08:12:22 -06:00
|
|
|
(3) both.
|
|
|
|
|
|
|
|
The method returns p_context, modified or not by evaluation of
|
|
|
|
p_expression on every matching object.
|
|
|
|
|
|
|
|
When you need to perform an action or computation on a lot of
|
|
|
|
objects, use this method instead of doing things like
|
|
|
|
|
|
|
|
"for obj in self.search(MyClass,...)"
|
|
|
|
'''
|
2010-10-14 07:43:56 -05:00
|
|
|
contentType = self.tool.o.getPortalType(klass)
|
2010-02-22 08:28:20 -06:00
|
|
|
search = Search('customSearch', sortBy=sortBy, **fields)
|
2010-01-18 08:12:22 -06:00
|
|
|
# Initialize the context variable "ctx"
|
|
|
|
ctx = context
|
2010-10-14 07:43:56 -05:00
|
|
|
for brain in self.tool.o.executeQuery(contentType, search=search, \
|
|
|
|
brainsOnly=True, maxResults=maxResults, noSecurity=noSecurity):
|
2010-01-18 08:12:22 -06:00
|
|
|
# Get the Appy object from the brain
|
|
|
|
obj = brain.getObject().appy()
|
|
|
|
exec expression
|
|
|
|
return ctx
|
|
|
|
|
2009-11-06 04:33:56 -06:00
|
|
|
def reindex(self):
|
|
|
|
'''Asks a direct object reindexing. In most cases you don't have to
|
|
|
|
reindex objects "manually" with this method. When an object is
|
|
|
|
modified after some user action has been performed, Appy reindexes
|
|
|
|
this object automatically. But if your code modifies other objects,
|
|
|
|
Appy may not know that they must be reindexed, too. So use this
|
|
|
|
method in those cases.'''
|
|
|
|
self.o.reindexObject()
|
|
|
|
|
2009-11-11 13:22:13 -06:00
|
|
|
def export(self, at='string'):
|
|
|
|
'''Creates an "exportable", XML version of this object. If p_at is
|
2010-03-31 08:49:54 -05:00
|
|
|
"string", this method returns the XML version, without the XML
|
|
|
|
prologue. Else, (a) if not p_at, the XML will be exported on disk,
|
|
|
|
in the OS temp folder, with an ugly name; (b) else, it will be
|
|
|
|
exported at path p_at.'''
|
2009-11-11 13:22:13 -06:00
|
|
|
# Determine where to put the result
|
|
|
|
toDisk = (at != 'string')
|
|
|
|
if toDisk and not at:
|
|
|
|
at = getOsTempFolder() + '/' + self.o.UID() + '.xml'
|
|
|
|
# Create the XML version of the object
|
2010-03-31 08:49:54 -05:00
|
|
|
marshaller = XmlMarshaller(cdata=True, dumpUnicode=True,
|
|
|
|
dumpXmlPrologue=toDisk,
|
|
|
|
rootTag=self.klass.__name__)
|
|
|
|
xml = marshaller.marshall(self.o, objectType='appy')
|
2009-11-11 13:22:13 -06:00
|
|
|
# Produce the desired result
|
|
|
|
if toDisk:
|
|
|
|
f = file(at, 'w')
|
2009-12-07 13:28:41 -06:00
|
|
|
f.write(xml.encode('utf-8'))
|
2009-11-11 13:22:13 -06:00
|
|
|
f.close()
|
|
|
|
return at
|
|
|
|
else:
|
|
|
|
return xml
|
|
|
|
|
2010-01-14 01:56:04 -06:00
|
|
|
def historize(self, data):
|
|
|
|
'''This method allows to add "manually" a "data-change" event into the
|
|
|
|
object's history. Indeed, data changes are "automatically" recorded
|
|
|
|
only when an object is edited through the edit form, not when a
|
|
|
|
setter is called from the code.
|
|
|
|
|
|
|
|
p_data must be a dictionary whose keys are field names (strings) and
|
|
|
|
whose values are the previous field values.'''
|
2010-10-14 07:43:56 -05:00
|
|
|
self.o.addDataChange(data)
|
2009-06-29 07:06:01 -05:00
|
|
|
# ------------------------------------------------------------------------------
|