"""New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""
"""Echo collection provides the classes for the ECHO content web-site.
class ECHO_collection is the basis class for an ECHO collection.
class ECHO_resource contains information on ECHO resources (e.g. an Display environment for Metadata
class ECHO_externalLink contains information on externalLinks
"""
import string
import re
import os
import OFS.Image
from types import *
from OFS.Image import Image
from Globals import DTMLFile
from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem
from AccessControl import ClassSecurityInfo
from AccessControl.User import UserFolder
from Globals import InitializeClass
from Globals import DTMLFile
import Globals
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Globals import Persistent, package_home
from Acquisition import Implicit
from ECHO_helpers import displayTypes
try:
from psycopg import libpq
except:
try:
from pyPgSQL import libpq
except:
print "ECHO_collection: Warning - No libpq imported!"
import xml.dom.minidom
import urllib
import xml.dom.minidom
from ECHO_graphicalOverview import javaHandler,javaScriptMain
import ECHO_helpers
#List of different types for the graphical linking viewer
viewClassificationListMaster=['view point','area']
def checkDiffs(self,metadict):
"""check differences"""
def NoneToEmpty(obj):
if obj:
return obj
else:
return ""
diffs={}
tags=self.findTagsFromMapping(self.contentType)
for field in tags[1]:
try:
if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):
diffs[self.getFieldTag(tags,field)]=1
else:
print "DIFF",field,self.getFieldValue(self.getFieldTag(tags,field)),metadict[self.getFieldTag(tags,field)]
diffs[self.getFieldTag(tags,field)]=0
except:
diffs[self.getFieldTag(tags,field)]=0
print "EX",field
return diffs
def content_html(self,type):
"""template fuer content"""
#templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])
#
#if templates:
# return templates[0][1]()
try:
obj=getattr(self,type+"_template")
return obj()
except:
pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)
pt.content_type="text/html"
return pt()
def toList(field):
"""Einzelfeld in Liste umwandeln"""
if type(field)==StringType:
return [field]
else:
return field
def getText(nodelist):
rc = ""
for node in nodelist:
if node.nodeType == node.TEXT_NODE:
rc = rc + node.data
return rc
def sendFile(self, filename, type):
"""sends an object or a local file (in the product) as response"""
paths = filename.split('/')
object = self
# look for an object called filename
for path in paths:
if hasattr(object, path):
object = getattr(object, path)
else:
object = None
break
if object:
# if the object exists then send it
return object.index_html(self.REQUEST.REQUEST, self.REQUEST.RESPONSE)
else:
# send a local file with the given content-type
fn = os.path.join(package_home(globals()), filename)
self.REQUEST.RESPONSE.setHeader("Content-Type", type)
self.REQUEST.RESPONSE.write(file(fn).read())
return
def writeMetadata(url,metadict):
"""Einlesen der Metadaten und und erstellen des geänderten XML file"""
try:
geturl=""
for line in urllib.urlopen(url).readlines():
geturl=geturl+line
except:
return (None,"Cannot open: "+url)
try:
dom=xml.dom.minidom.parseString(geturl)
except:
return (None,"Cannot parse: "+url+"
"+geturl)
metanodes=dom.getElementsByTagName('bib')
if not metanodes:
metanodes=dom.getElementsByTagName('archimedes')
metanode=metanodes[0]
for metaData in metadict.keys():
print metaData,metanode
try:
nodeOld=metanode.getElementsByTagName(metaData)
except:
nodeOld=None
if nodeOld:
metanode.removeChild(nodeOld[0]).unlink()
else:
# try also old writing rule - instead of _:
try:
nodeOld=metanode.getElementsByTagName(re.sub('_','-',metaData))
except:
nodeOld=None
if nodeOld:
metanode.removeChild(nodeOld[0]).unlink()
metanodeneu=dom.createElement(metaData)
metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf8"))
metanodeneu.appendChild(metanodetext)
metanode.appendChild(metanodeneu)
return dom.topxml().encode('utf-8')
def readMetadata(url):
"""Methode zum Auslesen der Metadateninformation zu einer Resource
Vorerst noch Typ bib"""
metadict={}
try:
geturl=""
for line in urllib.urlopen(url).readlines():
geturl=geturl+line
except:
return (None,"Cannot open: "+url)
try:
dom=xml.dom.minidom.parseString(geturl)
except:
return (None,"Cannot parse: "+url+"
"+geturl)
metanode=dom.getElementsByTagName('bib')
metadict['bib_type']='Book'
if len(metanode)==0:
metanode=dom.getElementsByTagName('archimedes')
metadict['bib_type']='Archimedes'
#print "HELLO"
if not len(metanode)==0:
metacontent=metanode[0].childNodes
try:
metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)
except:
"""nothing"""
for node in metacontent:
try:
metadict[re.sub('-','_',node.tagName.lower())]=getText(node.childNodes)
except:
"""nothing"""
return metadict,""
def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):
"""Allegemeine Informationen zu einer ECHO Collection"""
self.viewClassification=viewClassification
self.label = label
self.title=title
self.description=description
self.contentType=contentType
self.responsible=responsible
self.credits=toList(credits)
self.weight=weight
coords=[]
#coordinates of for rectangles
#print "cs", coordstrs
if coordstrs:
for coordstr in coordstrs:
#print "cs", coordstr
try:
temco=coordstr.split(",")
except:
temco=[]
#temco.append(angle)
coords.append(temco)
self.coords=coords[0:]
class scientificClassification(SimpleItem,Persistent,Implicit):
"""outdated will be deleeted in the next versions: subclass"""
security=ClassSecurityInfo()
def __init__(self,context,science,practice):
self.context=context
self.science=science
self.practice=practice
self.id="scientific_Classification"
security.declarePublic('get_context')
def get_context(self):
return self.context
security.declarePublic('get_science')
def get_science(self):
return self.science
security.declarePublic('get_practice')
def get_practice(self):
return self.practice
class scientificInformation(Folder,Persistent,Implicit):
"""outdated will be deleted in the next versions: subclass scientificInformation"""
security=ClassSecurityInfo()
def __init__(self,source_type,period):
self.id="scientific_Information"
self.source_type=source_type
self.period=period
security.declarePublic('get_source_type')
def get_source_type(self):
return self.source_type
security.declarePublic('get_period')
def get_period(self):
return self.period
class ECHO_layoutTemplate(ZopePageTemplate):
"""Create a layout Template for different purposes"""
meta_type="ECHO_layoutTemplate"
def __init__(self, id, text=None, content_type=None,EchoType=None):
self.id = str(id)
self.ZBindings_edit(self._default_bindings)
if text is None:
self._default_content_fn = os.path.join(package_home(globals()),
'zpt/ECHO_%s_template_standard.zpt'%EchoType)
text = open(self._default_content_fn).read()
self.pt_edit(text, content_type)
"""change form"""
def manage_addECHO_layoutTemplateForm(self):
"""Form for adding"""
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)
return pt()
from urllib import quote
def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
"Add a Page Template with optional file content."
if type(EchoType)==StringType:
EchoTypes=[EchoType]
else:
EchoTypes=EchoType
for singleType in EchoTypes:
id = str(singleType)+"_template"
if REQUEST is None:
self._setObject(id, ECHO_layoutTemplate(id, text,EchoType=singleType))
ob = getattr(self, id)
if title:
ob.pt_setTitle(title)
return ob
else:
file = REQUEST.form.get('file')
headers = getattr(file, 'headers', None)
if headers is None or not file.filename:
zpt = ECHO_layoutTemplate(id,EchoType=singleType)
else:
zpt = ECHO_layoutTemplate(id, file, headers.get('content_type'))
self._setObject(id, zpt)
ob = getattr(self, id)
if title:
ob.pt_setTitle(title)
try:
u = self.DestinationURL()
except AttributeError:
u = REQUEST['URL1']
REQUEST.RESPONSE.redirect(u+'/manage_main')
return ''
class ECHO_resource(Folder):
"""ECHO Ressource"""
meta_type='ECHO_resource'
viewClassificationList=viewClassificationListMaster
getSubCols = ECHO_helpers.getSubCols
def getTitle(self):
"""title"""
return self.title.encode('utf-8')
def getLabel(self):
"""title"""
return self.label.encode('utf-8')
def content_html(self):
"""template fuer content"""
return content_html(self,'resource')
def getViewClassification(self):
if hasattr(self,'viewClassification'):
return self.viewClassification
else:
return ""
def getFullTextXML(self,noredirect=None):
"""getFullTextXML"""
try:
fh=urllib.urlopen(self.metalink)
dom=xml.dom.minidom.parse(fh)
texttools=dom.getElementsByTagName('texttool')
text=texttools[0].getElementsByTagName('text')
texturl=getText(text[0].childNodes)
if not noredirect:
self.REQUEST.RESPONSE.redirect(texturl)
else:
return texturl
except:
return None
def getCredits(self):
"""Ausgabe der credits"""
if self.credits:
return self.credits
else:
return []
def __init__(self,id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords):
self.id = id
"""Festlegen der ID"""
self.label = label
self.link= link
self.metalink=metalink
self.title=title
self.weight=weight
self.credits=toList(credits)
self.description=description
self.contentType=contentType
self.responsible=responsible
if coords:
coordsnew=[ string.split(x,",") for x in coords]
else:
coordsnew=[]
self.coords=coordsnew
def getCoords(self):
"""gibt coordinaten als String zurück und löscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""
retList=[]
if hasattr(self,'coords'):
for x in self.coords:
if len(x)>1:
retList.append(string.join(x,","))
return retList
def getContentType(self):
try:
return self.contentType
except:
return ""
def getCopyrightType(self):
try:
return self.copyrightType
except:
return ""
def getRenderingType(self):
try:
return self.renderingType
except:
return ""
def ECHO_resource_config(self):
"""Main configuration"""
if not hasattr(self,'weight'):
self.weight=""
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)
return pt()
def ECHO_resource_config_main(self):
"""Main configuration"""
if not hasattr(self,'weight'):
self.weight=""
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)
return pt()
def ECHO_resource_config_coords(self):
"""Coords configuration """
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)
return pt()
def ECHO_resource_config_credits(self):
"""Main configuration"""
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)
return pt()
def ECHO_resource_config_metadata(self):
"""Main configuration"""
if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
self.metaDataHash={}
self.contentType=self.bib_type
for data in self.metadata:
data_neu=re.sub('-','_',data)
self.metaDataHash[data_neu]=getattr(self,data)
#print data_neu, getattr(self,data)
#print self.metaDataHash,self.metadata
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)
return pt()
def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):
"""Änderung der Properties"""
self.resourceID=resourceID
self.title=title
self.label=label
self.description=description
self.contentType=contentType
self.renderingType=renderingType
self.weight=weight
self.link=link
self.metalink=metalink
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):
"""Änderung der Properties - coords"""
if type(coords)==StringType:
coords=[coords]
try:
coordsnew=[ string.split(x,",") for x in coords]
except:
coordsnew=[]
self.coords=coordsnew[0:]
self.viewClassification=viewClassification
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):
"""Änderung der Properties"""
self.credits=credits
self.responsible=responsible
self.copyrightType=copyrightType
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def changeECHO_resource_metadata(self,RESPONSE=None):
"""change metadata"""
tags=self.findTagsFromMapping(self.contentType)
self.OSAS_meta={}
for field in tags[1]:
try:
self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
except:
"""nothing"""
return urllib.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML')).read()
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def newMetaXML(self):
"""new index.meta"""
self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
return writeMetadata(self.metalink,self.OSAS_meta)
def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,viewClassification="",coords=None,credits=None,RESPONSE=None):
"""Änderung der Properties"""
try:
coordsnew=[ string.split(x,",") for x in coords]
except:
coordsnew=[]
setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)
self.viewClassification=viewClassification
self.coords=coordsnew[0:]
self.link=link
self.metalink=metalink
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
manage_options = Folder.manage_options+(
{'label':'Main Config','action':'ECHO_resource_config_main'},
{'label':'Change Credits & Copyright','action':'ECHO_resource_config_credits'},
{'label':'Change Metadata','action':'ECHO_resource_config_metadata'},
{'label':'Change Coords','action':'ECHO_resource_config_coords'},
{'label':'Add coords','action':'ECHO_graphicEntry'},
{'label':'Sync Metadata','action':'ECHO_getResourceMD'},
)
def getOverview(self):
"""overview graphics"""
return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]
def ECHO_graphicEntry(self):
"""DO nothing"""
overview = self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])
if overview:
pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_draw.zpt').__of__(self)
return pt()
else:
return "NO OVERVIEW GRAPHICS"
def ECHO_enterCoords(self,coordstr,angle="",RESPONSE=None):
"""Enter coords"""
coords=self.coords
temco=coordstr.split(",")
temco.append(angle)
coords.append(temco)
self.coords=coords[0:]
if RESPONSE is not None:
RESPONSE.redirect('ECHO_graphicEntry')
def isDefinedInThisSet(self,fields,field):
"""checks if field is defined in fields"""
if (fields[0].has_key(field)) and not (fields[0][field]==""):
return 1
else:
return 0
def getFieldLabel(self,fields,field):
"""get labels"""
try:
ret =fields[0][field]
if ret == "":
return field
else:
return ret
except:
return field
def getFieldTag(self,fields,field):
"""get labels"""
try:
ret =fields[0][field]
if ret == "":
return field
else:
return ret
except:
return field
def getFieldValue(self,field):
"""get value"""
#print field
try:
ret=self.metaDataHash[field]
if ret == "":
return None
else:
return ret
except:
return None
def findLabelsFromMapping(self,referenceType):
"""gib hash mit label -> generic zurueck"""
self.referencetypes=self.ZopeFind(self.standardMD)
#print "RT",referenceType
bibdata={}
retdata={}
fieldlist=self.standardMD.fieldList
for referenceTypeF in self.referencetypes:
#print referenceTypeF[1].title,referenceType
if referenceTypeF[1].title.lower() == referenceType.lower():
#print "OK"
try:
bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
referenceType=referenceTypeF[1].title
except:
bibdata[referenceType]=referenceTypeF[1].fields
bibdata['data']=referenceTypeF[1]
self.fields=bibdata[referenceType]
for field in fieldlist:
retdata[field]=referenceTypeF[1].getValue(field)[1]
#print retdata,fieldlist
return retdata,fieldlist
def findTagsFromMapping(self,referenceType):
"""gib hash mit label -> generic zurueck"""
self.referencetypes=self.ZopeFind(self.standardMD)
bibdata={}
retdata={}
fieldlist=self.standardMD.fieldList
for referenceTypeF in self.referencetypes:
if referenceTypeF[1].title.lower() == referenceType.lower():
try:
bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
referenceType=referenceTypeF[1].title
except:
bibdata[referenceType]=referenceTypeF[1].fields
bibdata['data']=referenceTypeF[1]
self.fields=bibdata[referenceType]
for field in fieldlist:
retdata[field]=referenceTypeF[1].getValue(field)[0]
return retdata,fieldlist
def ECHO_getResourceMD(self,template="yes"):
"""Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
(metadict, error)=readMetadata(self.metalink)
if not error=="": #Fehler beim Auslesen des Metafiles
return "ERROR:",error
if not (metadict['bib_type'].lower()==self.contentType.lower()):
self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
self.REQUEST.SESSION['contentZope']=self.contentType
return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()
self.REQUEST.SESSION['metadict']=metadict
self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
if template=="yes":
pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)
return pt()
def ECHO_getMD(self,item):
"""Ausgabe der MD"""
return getattr(self,item)
def index_html(self):
"""standard page"""
return self.REQUEST.RESPONSE.redirect(self.link)
def generate_label(self):
"""Erzeugt_standard_Label aus Template"""
pt=getattr(self,"label_template_"+self.bib_type)
return pt()
def manage_addECHO_resourceForm(self):
"""Form for adding a ressource"""
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)
return pt()
def manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
"""addaresource"""
newObj=ECHO_resource(id,link,metalink,title,label,description,contentType,responsible,credits,weight,coords)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class ECHO_externalLink(Folder):
"""Link zu einer externen Ressource"""
security=ClassSecurityInfo()
meta_type='ECHO_externalLink'
def getTitle(self):
"""title"""
return self.title.encode('utf-8')
def getLabel(self):
"""title"""
return self.label.encode('utf-8')
def content_html(self):
"""template fuer content"""
return content_html(self,'externalLink')
def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):
self.id = id
"""Festlegen der ID"""
self.credits=toList(credits)
self.label = label
self.link= link
self.title=title
self.weight=weight
self.description=description
self.contentType=contentType
self.responsible=responsible
coordsnew=[ string.split(x,",") for x in coords]
self.coords=coordsnew
def ECHO_externalLink_config(self):
"""Main configuration"""
if not hasattr(self,'weight'):
self.weight=""
if not hasattr(self,'coords'):
self.coords=['']
#print "G",self.coords
pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)
return pt()
def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
"""Änderung der Properties"""
try:
coordsnew=[ string.split(x,",") for x in coords]
except:
coordsnew=[]
setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)
self.coords=coordsnew[0:]
self.link=link
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
manage_options = Folder.manage_options+(
{'label':'Main Config','action':'ECHO_externalLink_config'},
)
def getCredits(self):
"""Ausgabe der credits"""
if self.credits:
return self.credits
else:
return []
def index_html(self):
"""standard page"""
return self.REQUEST.RESPONSE.redirect(self.link)
def manage_addECHO_externalLinkForm(self):
"""Form for external Links"""
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)
return pt()
def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
"""Add an external Link"""
newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class ECHO_link(ECHO_externalLink):
"""external_link"""
meta_type="ECHO_link"
def content_html(self):
"""template fuer link"""
if hasattr(self,"link_template"):
return content_html(self,'link')
else:
return content_html(self,'collection')
def manage_addECHO_linkForm(self):
"""Form for external Links"""
pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)
return pt()
def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):
"""Add an external Link"""
newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class ECHO_collection(Folder, Persistent, Implicit):
"""ECHO Collection"""
security=ClassSecurityInfo()
meta_type='ECHO_collection'
viewClassificationList=viewClassificationListMaster
displayTypes=displayTypes
def getViewClassification(self):
if hasattr(self,'viewClassification'):
return self.viewClassification
else:
return ""
def getTitle(self):
"""title"""
return self.title.encode('utf-8')
def getLabel(self):
"""title"""
return self.label.encode('utf-8')
def createRessourcesFromXMLForm(self):
"""form"""
pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)
return pt()
def createRessourcesFromXML(self,fileupload):
"""read an XML file for generating resources"""
dom=xml.dom.minidom.parse(fileupload)
ret="
"+label+"
" manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","") return ret def getImageTag(self): """GetTag""" try: return self.imageTag except: return "" def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None): """SSS""" try: manage_addECHO_resource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None) return "done" except: return None def getSecondaryLink(self): """secondary link""" try: return self.secondaryLink except: return "" def getSecondaryLinkTitle(self): """secondary link""" try: return self.secondaryLinkTitle except: return "" def getCollectionTreeXML(self): """Tree as XML""" def getCollection(object,depth=0): depth+=1 collections="" for entry in object.__dict__.keys(): element=getattr(object,entry) try: if element.meta_type in ["ECHO_collection","ECHO_group"]: collections+="