def test_pystr(self):
self.assertEquals(standard.pystr('ABC'), 'ABC')
self.assertEquals(standard.pystr_('ABC'), 'ABC')
self.assertEquals(standard.pystr(b'ABC'), 'ABC')
self.assertEquals(standard.pystr_(b'ABC'), 'b\'ABC\'')
self.assertEquals(standard.pystr(123), '123')
self.assertEquals(standard.pystr_(123), '123')
def toXml(self, sender=None, base_path='', data2hex=True):
"""
Serialize this file to xml-string.
@param sender: the sender-node
@type sender: C{zmsobject.ZMSObject=None}
@param base_path: the base-path
@type base_path: C{str=''}
@param data2hex: convert data inline to hex, otherwise saved to file in base-path
@type data2hex: C{Bool=True}
@return: the xml-string
@rtype: C{str}
"""
data = ''
objtype = ''
filename = _fileutil.getOSPath(_fileutil.extractFilename(getattr(self, 'filename', '')))
content_type = getattr(self, 'content_type', '')
if data2hex:
if content_type.startswith('text/') or content_type in ['application/css','application/javascript','image/svg']:
data = '<![CDATA[%s]]>'%standard.pystr(self.getData(sender),'utf-8')
else:
data = standard.bin2hex(standard.pybytes(self.getData(sender)))
objtype = ' type="image"'
else:
filename = self.getFilename()
filename = getLangFilename(sender, filename, self.lang)
filename = '%s%s'%(base_path, filename)
xml = '\n<data'
xml += ' width="%s"'%standard.pystr(getattr(self, 'width', ''))
xml += ' height="%s"'%standard.pystr(getattr(self, 'height', ''))
xml += ' content_type="%s"'%content_type
xml += ' filename="%s"'%filename
xml += objtype + '>' + data
xml += '</data>'
return xml
def __get_add_xml(self, node, recursive, xmlattrs={}):
zcm = self.getCatalogAdapter()
attrs = zcm.getAttrs()
xml = []
xml.append('<?xml version="1.0"?>')
xml.append('<add' + ' '.join(
[''] +
['%s="%s"' % (x, standard.pystr(xmlattrs[x]))
for x in xmlattrs]) + '>')
def cb(node, d):
xml.append('<doc>')
text = []
for k in d:
name = k
boost = 1.0
v = d[k]
if k not in ['id']:
if k in attrs:
boost = attrs[k]['boost']
if type(v) in (str, str):
name = '%s_t' % k
text.append(v)
else:
if type(v) in (str, str):
name = '%s_s' % k
xml.append('<field name="%s" boost="%.1f">%s</field>' %
(name, boost, v))
xml.append('<field name="text_t">%s</field>' %
' '.join([x for x in text if x]))
xml.append('</doc>')
zcm.get_sitemap(cb, node, recursive)
xml.append('</add>')
return '\n'.join(xml)
def uploadBlobField(self, clazz, file=b'', filename=''):
try:
file = file.read()
except:
pass
f = None
if isinstance(file,six.string_types):
f = re.findall('^data:(.*?);base64,([\s\S]*)$',file)
if f:
mt = f[0][0]
file = base64.b64decode(f[0][1])
else:
mt, enc = standard.guess_content_type(filename,file)
if clazz in [_globals.DT_IMAGE, 'image'] or mt.startswith('image'):
clazz = MyImage
elif clazz in [_globals.DT_FILE, 'file']:
clazz = MyFile
# blob = clazz( id='', title='', file='')
blob = clazz( id='', title='', file=standard.pybytes('','utf-8'))
blob.update_data(file, content_type=mt, size=len(file))
blob.aq_parent = self
blob.mediadbfile = None
blob.filename = standard.pystr(_fileutil.extractFilename( filename, undoable=True))
# Check size.
if self is not None:
maxlength_prop = 'ZMS.input.%s.maxlength'%['file','image'][isinstance(blob,MyImage)]
maxlength = self.getConfProperty(maxlength_prop, '')
if len(maxlength) > 0:
size = blob.get_size()
if size > int(maxlength):
raise zExceptions.Forbidden('size=%i > %s=%i' %(size, maxlength_prop, int(maxlength)))
return blob
def remove_tags(self, s):
d = {
'–':'-',
'·': '.',
' ': ' ',
'“': '',
'§': '',
'Ä': u'Ä',
'Ö': u'Ö',
'Ü': u'Ü',
'ä': u'ä',
'ö': u'ö',
'ü': u'ü',
'ß': u'ß'}
s = standard.pystr(s)
for x in d:
s = s.replace(x,d[x])
s = standard.re_sub('<script(.*?)>(.|\\n|\\r|\\t)*?</script>', ' ', s)
s = standard.re_sub('<style(.*?)>(.|\\n|\\r|\\t)*?</style>', ' ', s)
s = standard.re_sub('<[^>]*>', ' ', s)
while s.find('\t') >= 0:
s = s.replace('\t', ' ')
while s.find('\n') >= 0:
s = s.replace('\n', ' ')
while s.find('\r') >= 0:
s = s.replace('\r', ' ')
while s.find(' ') >= 0:
s = s.replace(' ', ' ')
s = s.strip()
return s
def OnEndElement(self, name):
""" Builder.OnEndElement """
if True:
standard.writeLog(
self, "[Builder.OnEndElement(" + standard.pystr(name) + ")]")
skip = self.oCurrNode is not None and len(
[x for x in self.oCurrNode.dTagStack if x.get('skip')]) > 0
if not skip and name == self.oCurrNode.meta_id:
standard.writeLog(self,
"[Builder.OnEndElement]: object finished")
##### VersionManager ####
self.oCurrNode.resetObjStates()
# notify current node
self.oCurrNode.xmlOnEndElement()
parent = self.oCurrNode.xmlGetParent()
# set parent node as current node
self.oCurrNode = parent
else:
# tag name is unknown -> offer it to current object
if not self.oCurrNode.xmlOnUnknownEndTag(name):
standard.writeLog(
self, "[Builder.OnEndElement]: Unknown end-tag (/" +
name + ")") # current object did not accept tag!
raise ParseError("Unknown end-tag (" + name +
")") # current object did not accept tag!
def traverse(base, path, level=0):
names = os.listdir(path)
for name in names:
filepath = os.path.join(path, name)
if os.path.isdir(filepath) and (deep or level == 0):
traverse(base, filepath, level + 1)
elif name.startswith('__') and name.endswith('__.py'):
# Read python-representation of repository-object
standard.writeLog(self,
"[readRepository]: read %s" % filepath)
f = open(filepath, "rb")
py = standard.pystr(f.read())
f.close()
# Analyze python-representation of repository-object
d = {}
try:
c = get_class(py)
d = c.__dict__
except:
d['revision'] = standard.writeError(
self, "[readRepository]: ")
id = d.get('id', name)
r[id] = {}
for k in [x for x in d if not x.startswith('__')]:
v = d[k]
if inspect.isclass(v):
dd = v.__dict__
v = []
for kk in [
x for x in dd if not x.startswith('__')
]:
vv = dd[kk]
# Try to read artefact.
if 'id' in vv:
fileprefix = vv['id'].split('/')[-1]
for file in [
x for x in names if x == fileprefix
or x.startswith('%s.' % fileprefix)
]:
artefact = os.path.join(path, file)
standard.writeLog(
self,
"[readRepository]: read artefact %s"
% artefact)
f = open(artefact, "rb")
data = f.read()
f.close()
try:
if isinstance(data, bytes):
data = data.decode('utf-8')
except:
pass
vv['data'] = data
break
v.append((py.find('\t\t%s =' % kk), vv))
v.sort()
v = [x[1] for x in v]
r[id][k] = v
def tal_anchor(self, href, target='', attrs={}, content=''):
filtered_attrs_keys = [x for x in attrs if x]
str_attrs = ' '.join([
'%s=\042%s\042' % (standard.pystr(x), str(attrs[x]))
for x in filtered_attrs_keys
])
return '<a href="%s" %s %s>%s</a>' % (href, [
'', ' target="%s"' % target
][int(len(target) > 0)], str_attrs, content)
def getInlineRefs(text):
l = []
p = '<a(.*?)>(.*?)<\\/a>'
r = re.compile(p)
for f in r.findall(standard.pystr(text)):
d = dict(re.findall('\\s(.*?)="(.*?)"', f[0]))
if 'data-id' in d:
l.append(d['data-id'])
return l
def exportFiles(self, root, id, path):
if hasattr(root, id):
folder = getattr(root, id)
for ob in folder.objectValues(['File', 'Image']):
try:
ob_id = ob.id()
except:
ob_id = standard.pystr(ob.id)
_fileutil.exportObj(ob, '%s/%s' % (path, ob_id))
def __get_delete_xml(self, query='*:*', attrs={}):
xml = []
xml.append('<?xml version="1.0"?>')
xml.append('<delete' + ' '.join(
[''] + ['%s="%s"' % (x, standard.pystr(attrs[x]))
for x in attrs]) + '>')
xml.append('<query>%s</query>' % query)
xml.append('</delete>')
return '\n'.join(xml)
def getText(nodelist, encoding='utf-8'):
rc = []
if not isinstance(nodelist, list):
nodelist = [nodelist]
for node in nodelist:
for childNode in node.childNodes:
if childNode.nodeType == childNode.TEXT_NODE:
rc.append(childNode.data)
return standard.pystr(''.join(rc).encode(encoding))
def __init__(self, filters={}, processes={}):
self.id = 'filter_manager'
self.filters = {}
for x in filters:
try:
self.setFilter(None, x['id'], x['acquired'], x['name'], x['format'], x['content_type'], x['description'], x['roles'], x['meta_types'])
index = 0
for p in x.get('processes', []):
self.setFilterProcess(x['id'], index, p['id'], p['file'])
index += 1
except:
standard.writeError(self,'can\'t __init__ filter: %s'%standard.pystr(x))
self.processes = {}
for x in processes:
try:
self.setProcess(None, x['id'], x['acquired'], x['name'], x['type'], x['command'])
except:
standard.writeError(self,'can\'t __init__ process: %s'%standard.pystr(x))
def sort_item(i):
if not isinstance(i, int):
i = standard.pystr(i)
mapping = umlaut_map
for key in mapping:
try:
i = i.replace(key, mapping[key])
except:
pass
return i
def getText(self, REQUEST, key='text', encoding='utf-8', errors='strict'):
s = self.getObjProperty(key, REQUEST)
if self.isPageElement():
sec_no = self.getSecNo()
if len(sec_no) > 0:
s = '%s %s' % (sec_no, s)
if six.PY2:
return standard.pystr(s, encoding, errors)
else:
return s
def getFilename(self):
"""
Returns filename.
@rtype: C{string}
"""
filename = standard.pystr(self.filename)
while filename.startswith('_'):
filename = filename[1:]
filename = "".join(x for x in filename if (x.isalnum() or x in "._-"))
if filename != self.filename and len(self.data) > 0:
self.filename = filename
return filename
def traverse(base, path):
names = os.listdir(path)
for name in names:
filepath = os.path.join(path, name)
if os.path.isdir(filepath):
traverse(base, filepath)
elif name.startswith('__') and name.endswith('__.py'):
# Read python-representation of repository-object
standard.writeLog(self,
"[remoteFiles]: read %s" % filepath)
f = open(filepath, "rb")
py = standard.pystr(f.read())
f.close()
# Analyze python-representation of repository-object
d = {}
try:
c = get_class(py)
d = c.__dict__
except:
d['revision'] = standard.writeError(
self,
"[traverse]: can't analyze filepath=%s" % filepath)
id = d.get('id', name)
rd = {}
rd['id'] = id
rd['filename'] = filepath[len(base) + 1:]
rd['data'] = py
rd['version'] = d.get(
"revision",
self.getLangFmtDate(os.path.getmtime(filepath), 'eng'))
r[rd['filename']] = rd
# Read artefacts and avoid processing of hidden files, e.g. .DS_Store on macOS
for file in [
x for x in names
if x != name and not x.startswith('.')
]:
artefact = os.path.join(path, file)
if os.path.isfile(artefact):
standard.writeLog(
self,
"[remoteFiles]: read artefact %s" % artefact)
f = open(artefact, "rb")
data = f.read()
f.close()
rd = {}
rd['id'] = id
rd['filename'] = artefact[len(base) + 1:]
rd['data'] = data
rd['version'] = self.getLangFmtDate(
os.path.getmtime(artefact), 'eng')
r[rd['filename']] = rd
def readData(ob, default=None):
"""
Read data of Zope-object.
"""
data = default
if ob is None and default is not None:
return default
if ob.meta_type in [ 'DTML Document', 'DTML Method', 'Filesystem DTML Document', 'Filesystem DTML Method']:
data = ob.raw
elif ob.meta_type in [ 'File', 'Filesystem File', 'Filesystem Image', 'Image']:
data = ob.data
if not standard.is_bytes(data):
b = b''
while data is not None:
b += data.data
data = data.next
data = b
elif ob.meta_type in [ 'Filesystem Page Template', 'Filesystem Script (Python)', 'Page Template', 'Script (Python)']:
data = ob.read()
elif ob.meta_type in [ 'External Method']:
if isinstance(ob,MissingArtefactProxy):
return ob.getData()
else:
context = ob
id = ob.getId()
while context is not None:
m = getExternalMethodModuleName(context, id)
filepath = standard.getINSTANCE_HOME()+'/Extensions/'+m+'.py'
if os.path.exists(filepath):
break
try:
context = context.getParentNode()
except:
context = None
if context is None:
m = id
filepath = standard.getINSTANCE_HOME()+'/Extensions/'+m+'.py'
if os.path.exists(filepath):
f = open(filepath, 'rb')
data = standard.pystr(f.read(),encoding='utf-8')
f.close()
elif ob.meta_type == 'Z SQL Method':
lines = []
lines.append('<connection>%s</connection>'%ob.connection_id)
lines.append('<params>%s</params>'%ob.arguments_src)
lines.append('<max_rows>%i</max_rows>'%ob.max_rows_)
lines.append('<max_cache>%i</max_cache>'%ob.max_cache_)
lines.append('<cache_time>%i</cache_time>'%ob.cache_time_)
lines.append(ob.src)
data = '\n'.join(lines)
return data
def addObject(container, meta_type, id, title, data, permissions={}):
"""
Add Zope-object to container.
"""
if meta_type == 'DTML Document':
if not isinstance(data, str):
# Enforce to utf-8 text
data = standard.pystr(data, encoding='utf-8',
errors='replace').encode('utf-8')
addDTMLDocument(container, id, title, data)
elif meta_type == 'DTML Method':
if not isinstance(data, str):
# Enforce to utf-8 text
data = standard.pystr(data, encoding='utf-8',
errors='replace').encode('utf-8')
addDTMLMethod(container, id, title, data)
elif meta_type == 'External Method':
addExternalMethod(container, id, title, data)
elif meta_type == 'File':
addFile(container, id, title, data)
elif meta_type == 'Image':
if isinstance(data, str): # SVG Images
data = data.encode('utf-8')
addImage(container, id, title, data)
elif meta_type == 'Page Template':
if not isinstance(data, str):
# Enforce to utf-8 text
data = standard.pystr(data, encoding='utf-8',
errors='replace').encode('utf-8')
addPageTemplate(container, id, title, data)
elif meta_type == 'Script (Python)':
addPythonScript(container, id, title, data)
elif meta_type == 'Folder':
addFolder(container, id, title)
elif meta_type == 'Z SQL Method':
addZSqlMethod(container, id, title, data)
initPermissions(container, id, permissions)
return getObject(container, id)
def localHtml(self, html):
try:
default_charset = 'utf-8'
charset = self.REQUEST.get('ZMS_CHARSET', default_charset)
if not isinstance(html, str):
html = standard.pystr(html, default_charset)
html = html.encode(charset)
except (UnicodeDecodeError, UnicodeEncodeError):
standard.writeError(self, "[localHtml]")
v = standard.pystr(sys.exc_info()[1])
STR_POSITION = ' position '
i = v.find(STR_POSITION)
if i > 0:
v = v[i + len(STR_POSITION):]
if v.find('-') > 0:
l = int(v[:v.find('-')])
h = int(v[v.find('-') + 1:v.find(':')])
else:
l = int(v[:v.find(':')])
h = l
ln = max(l - 20, 0)
hn = min(h + 20, len(html))
return html
def search_xml(self,
q,
page_index=0,
page_size=10,
REQUEST=None,
RESPONSE=None):
""" ZMSZCatalogSolrConnector.search_xml """
# Check constraints.
zcm = self.getCatalogAdapter()
attrs = zcm.getAttrs()
page_index = int(page_index)
page_size = int(page_size)
REQUEST.set('lang', REQUEST.get('lang', self.getPrimaryLanguage()))
RESPONSE = REQUEST.RESPONSE
content_type = 'text/xml; charset=utf-8'
RESPONSE.setHeader('Content-Type', content_type)
RESPONSE.setHeader('Cache-Control', 'no-cache')
RESPONSE.setHeader('Pragma', 'no-cache')
RESPONSE.setHeader('Access-Control-Allow-Origin', '*')
# Execute query.
p = {}
p['q'] = q
p['wt'] = 'xml'
p['start'] = page_index
p['rows'] = page_size
p['defType'] = 'edismax'
p['qf'] = ' '.join([
'%s^%s' % (self._get_field_name(x),
standard.pystr(attrs[x].get('boost', 1.0)))
for x in attrs
])
p['hl'] = 'true'
p['hl.fragsize'] = self.getConfProperty('solr.select.hl.fragsize', 200)
p['hl.fl'] = self.getConfProperty(
'solr.select.hl.fl',
','.join([self._get_field_name(x) for x in attrs]))
p['hl.simple.pre'] = self.getConfProperty('solr.select.hl.simple.pre',
'<span class="highlight">')
p['hl.simple.post'] = self.getConfProperty(
'solr.select.hl.simple.post', '</span>')
solr_url = self.getConfProperty('solr.url',
'http://localhost:8983/solr')
solr_core = self.getConfProperty('solr.core',
self.getAbsoluteHome().id)
url = '%s/%s/select' % (solr_url, solr_core)
url = self.url_append_params(url, p, sep='&')
result = self.http_import(url, method='GET')
result = standard.re_sub('name="(.*?)_[ist]"', 'name="\\1"', result)
return result
def update_extract(action, data):
solr_url = zmscontext.getConfProperty('solr.url',
'http://localhost:8983/solr')
solr_core = zmscontext.getConfProperty('solr.core', home_id)
url = '%s/%s/update/extract' % (solr_url, solr_core)
standard.writeLog(
zmscontext,
"[manage_zcatalog_update_documents.update]: %s=%s" % (action, url))
response = standard.pystr(
standard.http_request(
url,
method='POST',
data=data,
headers={'Content-Type': 'multipart/form-data'}))
standard.writeLog(
zmscontext, "[manage_zcatalog_update_documents.update]: %s=%s" %
(action, response))
return '%s=%s' % (action, response)
def update(action, xml):
solr_url = zmscontext.getConfProperty('solr.url',
'http://localhost:8983/solr')
solr_core = zmscontext.getConfProperty('solr.core', home_id)
url = '%s/%s/update' % (solr_url, solr_core)
url = '%s?%s' % (url, xml)
standard.writeLog(
zmscontext,
"[manage_zcatalog_update_documents.update]: %s=%s" % (action, url))
result = standard.pystr(
standard.http_import(
zmscontext,
url,
method='POST',
headers={'Content-Type': 'text/xml;charset=UTF-8'}))
standard.writeLog(
zmscontext, "[manage_zcatalog_update_documents.update]: %s=%s" %
(action, result))
return '%s=%s' % (action, result)
def renderText(self,
text,
REQUEST,
id=None,
clazz=None,
encoding='utf-8',
errors='strict'):
html = ''
# Open tag.
html += self.getStartTag(id, clazz)
# Sub tag.
text = br_quote(text, self.getSubTag(), REQUEST)
# Value.
try:
html += standard.pystr(text, encoding, errors)
except:
html += text
# Close tag.
html += self.getEndTag()
# Return.
return html
def zmi_manage_css(self, *args, **kwargs):
""" ZMSItem.zmi_manage_css """
warn(self, 'zmi_manage_css', 'None')
request = self.REQUEST
response = request.RESPONSE
response.setHeader('Content-Type', 'text/css')
css = []
for stylesheet in self.getStylesheets():
try:
s = stylesheet(self)
except:
s = standard.pystr(stylesheet)
css.append(
"/* ######################################################################"
)
css.append(" ### %s" % stylesheet.absolute_url())
css.append(
" ###################################################################### */"
)
css.append(s)
return '\n'.join(css)
def manage_changeProperties(self, lang, REQUEST, RESPONSE):
""" ZMSLinkElement.manage_changeProperties """
target_ob = self.getParentNode()
if REQUEST.get('menulock',0) == 1:
# Remain in Current Menu
target_ob = self
target = REQUEST.get( 'manage_target', '%s/manage_main'%target_ob.absolute_url())
message = ''
if REQUEST.get('btn', '') not in [ 'BTN_CANCEL', 'BTN_BACK']:
try:
##### Object State ####
self.setObjStateModified(REQUEST)
##### Properties ####
for key in self.getObjAttrs():
obj_attr = self.getObjAttr(key)
if obj_attr['xml']:
self.setReqProperty(key, REQUEST)
##### VersionManager ####
self.onChangeObj(REQUEST)
##### Success Message ####
message = self.getZMILangStr('MSG_CHANGED')
##### Failure Message ####
except ConstraintViolation:
target = REQUEST.get( 'manage_target', '%s/manage_main'%self.absolute_url())
message = "[ConstraintViolation]: " + standard.pystr( sys.exc_info()[1])
# Return with message.
target = self.url_append_params( target, { 'lang': lang, 'manage_tabs_message': message})
target = '%s#zmi_item_%s'%( target, self.id)
return RESPONSE.redirect( target)
def search_xml(self,
q,
page_index=0,
page_size=10,
REQUEST=None,
RESPONSE=None):
""" ZMSZCatalogConnector.search_xml """
# Check constraints.
page_index = int(page_index)
page_size = int(page_size)
REQUEST.set('lang', REQUEST.get('lang', self.getPrimaryLanguage()))
RESPONSE = REQUEST.RESPONSE
content_type = 'text/xml;charset=utf-8'
RESPONSE.setHeader('Content-Type', content_type)
RESPONSE.setHeader('Cache-Control', 'no-cache')
RESPONSE.setHeader('Pragma', 'no-cache')
RESPONSE.setHeader('Access-Control-Allow-Origin', '*')
# Execute query.
status = 0
msg = ''
results = []
try:
results = self.search(q, REQUEST.get('fq[]', ''))
except:
standard.writeError(self, '[search_xml]')
t, v, tb = sys.exc_info()
status = 400
msg = v
# Assemble xml.
xml = self.getXmlHeader()
xml += '<response>'
xml += '<lst name="responseHeader">'
xml += '<int name="status">%i</int>' % status
xml += '<lst name="params">'
for key in REQUEST.form.keys():
xml += '<str name="%s">%s</str>' % (
key, standard.html_quote(REQUEST.form[key]))
xml += '</lst>'
xml += '</lst>'
xmlr = ''
if status <= 0:
xmlr += '<result name="response" numFound="%i" start="%i">' % (
len(results), page_index * page_size)
if len(results) > page_size:
results = results[page_index * page_size:(page_index + 1) *
page_size]
for result in results:
xmlr += '<doc>'
for k in result.keys():
try:
v = result[k]
if k == 'zcat_column_loc':
k = 'loc'
elif k == 'zcat_column_index_html':
k = 'index_html'
elif k == 'zcat_column_custom':
k = 'custom'
elif k == 'standard_html':
v = ZMSZCatalogAdapter.remove_tags(self, v)
xmlr += '<arr name="%s">' % k
if isinstance(v, str):
for x in range(16):
v = v.replace(chr(x), '')
if k == 'custom':
xmlr += '<str>%s</str>' % v
else:
xmlr += '<str><![CDATA[%s]]></str>' % v
xmlr += '</arr>'
except:
standard.writeError(
self,
'[search_xml]: result=%s, k=%s' % (str(result), k))
t, v, tb = sys.exc_info()
status = 400
msg = v
break
xmlr += '</doc>'
xmlr += '</result>'
if status > 0:
xmlr = ''
xmlr += '<lst name="error">'
xmlr += '<str name="msg">%s</str>' % standard.html_quote(msg)
xmlr += '<int name="code">%i</int>' % status
xmlr += '</lst>'
xml += standard.pystr(xmlr)
xml += '</response>'
return xml
def toXml(self, value, indentlevel=0, xhtml=False, encoding='utf-8'):
xml = []
if value is not None:
# Image
if isinstance(value, _blobfields.MyImage):
xml.append('\n' + indentlevel * INDENTSTR + value.toXml(self))
# File
elif isinstance(value, _blobfields.MyFile):
xml.append('\n' + indentlevel * INDENTSTR + value.toXml(self))
# File (Zope-native)
elif isinstance(value, File):
tagname = 'data'
content_type = value.content_type
xml.append('\n' + indentlevel * INDENTSTR)
xml.append('<%s' % tagname)
xml.append(' content_type="%s"' % content_type)
xml.append(' filename="%s"' % value.title)
xml.append(' type="file"')
xml.append('>')
data = zopeutil.readData(value)
if content_type.startswith('text/') or content_type in ['application/css','application/javascript','image/svg']:
try:
data = standard.pystr(data,'utf-8')
except:
pass
cdata = None
# Ensure CDATA is valid.
try:
cdata = '<![CDATA[%s]]>'%data
p = pyexpat.ParserCreate()
rv = p.Parse('<?xml version="1.0" encoding="utf-8"?><%s>%s</%s>'%(tagname,cdata,tagname), 1)
# Otherwise use binary encoding.
except:
cdata = standard.bin2hex(standard.pybytes(data))
xml.append(cdata)
xml.append('</%s>' % tagname)
# Dictionaries
elif isinstance(value, dict):
keys = sorted(value)
xml.append('\n' + indentlevel * INDENTSTR)
xml.append('<dictionary>')
indentstr = '\n' + (indentlevel + 1) * INDENTSTR
for x in keys:
k = ' key="%s"' % x
xv = value[x]
tv = getXmlType(xv)
sv = toXml(self, xv, indentlevel + 2, xhtml, encoding)
xml.append(indentstr)
xml.append('<item%s%s>' % (k, tv))
xml.append(sv)
if sv.find('\n') >= 0:
xml.append(indentstr)
xml.append('</item>')
xml.append('\n' + indentlevel * INDENTSTR)
xml.append('</dictionary>')
# Lists
elif isinstance(value, list):
xml.append('\n' + indentlevel * INDENTSTR)
xml.append('<list>')
indentstr = '\n' + (indentlevel + 1) * INDENTSTR
for xv in value:
k = ''
tv = getXmlType(xv)
sv = toXml(self, xv, indentlevel + 2, xhtml, encoding)
xml.append(indentstr)
xml.append('<item%s%s>' % (k, tv))
xml.append(sv)
if sv.startswith('\n'):
xml.append(indentstr)
xml.append('</item>')
xml.append('\n' + indentlevel * INDENTSTR)
xml.append('</list>')
# Tuples (DateTime)
elif isinstance(value, tuple) or isinstance(value, time.struct_time) or isinstance(value, DateTime):
try:
s_value = self.getLangFmtDate(value, 'eng', 'DATETIME_FMT')
if len(s_value) > 0:
xml.append('\n' + indentlevel * INDENTSTR)
xml.append(toCdata(self, s_value, -1))
except:
pass
# Numbers
elif isinstance(value, int) or isinstance(value, float):
xml.append(value)
else:
# Zope-Objects
try: meta_type = value.meta_type
except: meta_type = None
if meta_type is not None:
value = zopeutil.readData(value)
if value:
xml.append(toCdata(self, value, xhtml))
# Return xml.
return ''.join([standard.pystr(x) for x in xml])
def toCdata(self, s, xhtml=False):
rtn = ''
# Return Text (HTML) in CDATA as XHTML.
from Products.zms import _filtermanager
processId = 'tidy'
if not xhtml \
and self.getConfProperty('ZMS.export.xml.tidy', 0) \
and processId in self.getProcessIds():
# Create temporary folder.
folder = tempfile.mktemp()
os.mkdir(folder)
# Save <HTML> to file.
filename = _fileutil.getOSPath('%s/xhtml.html' % folder)
_fileutil.exportObj(s, filename)
# Call <HTML>Tidy
processOb = self.getProcess(processId)
command = processOb.get('command')
if command.find('{trans}') >= 0:
trans = _fileutil.getOSPath(package_home(globals()) + '/conf/xsl/tidy.html2xhtml.conf')
command = command.replace('{trans}', trans)
filename = _filtermanager.processCommand(self, filename, command)
# Read <XHTML> from file.
f = open(htmfilename, 'rb')
rtn = f.read().strip()
f.close()
# Read Error-Log from file.
f = open(logfilename, 'rb')
log = f.read().strip()
f.close()
# Remove temporary files.
_fileutil.remove(folder, deep=1)
# Process <XHTML>.
prefix = '<p>'
if s[:len(prefix)] != prefix and rtn[:len(prefix)] == prefix:
rtn = rtn[len(prefix):]
suffix = '</p>'
if s[-len(suffix):] != suffix and rtn[-len(suffix):] == suffix:
rtn = rtn[:-len(suffix)]
f.close()
# Process Error-Log.
if log.find('0 errors') < 0:
rtn += '<!-- ' + log + '-->'
# Return Text.
elif standard.is_str(s) and s.find(' ') < 0 and s.find('<') < 0 and s.find('&') < 0:
rtn = s
# Return Text in CDATA.
elif s is not None:
if standard.is_bytes(s):
s = standard.pystr(s)
# Hack for invalid characters
s = s.replace(chr(30), '')
# Hack for nested CDATA
s = re.compile(r'\<\!\[CDATA\[(.*?)\]\]\>').sub(r'<!{CDATA{\1}}>', s)
# Wrap with CDATA
rtn = '<![CDATA[%s]]>' % s
# Return.
return rtn
def getData(self, parent=None):
"""
Returns data.
"""
data = ''
mediadbfile = self.getMediadbfile()
if mediadbfile is not None:
if parent is None:
parent = self.aq_parent
mediadb = parent.getMediaDb()
if mediadb is not None:
try:
data = mediadb.retrieveFile( mediadbfile)
except:
standard.writeError( parent, "[getData]: can't retrieve file from mediadb: %s"%standard.pystr(mediadbfile))
else:
data = getattr(self, 'data', '')
return data
