[BACK]Return to ECHO_collection.py CVS log [TXT] [DIR] Up to [Repository] / ECHO_content

Diff for /ECHO_content/ECHO_collection.py between versions 1.168 and 1.310.2.1

version 1.168, 2004/09/01 14:32:32 version 1.310.2.1, 2011/10/13 07:48:27
Line 1 Line 1
 """New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""  """New version of the produc started February, 8th. Without scientific classification, use content-type for further classification."""
 """Echo collection provides the classes for the ECHO content web-site.  """Echo collection provides the classes for the ECHO content web-site.
   
 class ECHO_collection is the basis class for an ECHO collection.  class ECHO_collection is the basis class for an ECHO collection.
Line 9  class ECHO_externalLink contains informa Line 9  class ECHO_externalLink contains informa
   
   
 """  """
   
        
   import urlparse
 import string  import string
   import tempfile
   import zipfile
 import re  import re
 import os  import os,shutil
 import OFS.Image  import OFS.Image
 from types import *  from types import *
 from OFS.Cache import Cacheable  from OFS.Cache import Cacheable
Line 26  from Globals import DTMLFile Line 31  from Globals import DTMLFile
 import Globals  import Globals
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate,manage_addPageTemplate
 from Globals import Persistent, package_home  from Globals import Persistent, package_home
 from Acquisition import Implicit  from Acquisition import Implicit
 from ECHO_helpers import displayTypes  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
   try:
       from Products.MetaDataProvider.MetaDataClient import MetaDataClient
   except:
       print "no metadataclient"
 import urllib  import urllib
   import urllib2
   import cgi
   import smtplib
 import time  import time
   #from Ft.Xml.Domlette import NonvalidatingReader
   #from Ft.Xml.Domlette import PrettyPrint, Print
   #from Ft.Xml import EMPTY_NAMESPACE
   #
   #import Ft.Xml.XPath
   import cStringIO
   
   import sys
   import logging
   
 try:  try:
     from psycopg import libpq      from psycopg import libpq
Line 45  import xml.dom.minidom Line 67  import xml.dom.minidom
   
 import urllib  import urllib
 import xml.dom.minidom  import xml.dom.minidom
 from ECHO_graphicalOverview import javaHandler,javaScriptMain  
 import ECHO_helpers  import ECHO_helpers
   from ECHO_helpers import *
   
 def donatus(txt2):  
     import xmlrpclib  
   
     server = xmlrpclib.ServerProxy("http://archimedes.fas.harvard.edu/cgi-bin/donatus-rpc")  
   
     txt=txt2.encode('utf-8')  
     bin=xmlrpclib.Binary(txt)  
   
       
   
     ret=server.donatus.analyze(bin)  
   
           
     return ret['morphData'].data  
   
   
 def donatusVariant2Lemma(morphData):  
     """creates hash variant -> morphdata"""  
     ret={}  
     dom=xml.dom.minidom.parseString(morphData)  
     lemmas=dom.getElementsByTagName('lemma')  
     for lemma in lemmas:  
         variants=lemma.getElementsByTagName('variant')  
         for variant in variants:  
             atr=variant.getAttribute('form')  
             if ret.has_key(atr):  
                 ret[atr].append=lemma.getAttribute('form')  
             else:  
                 ret[atr]=[lemma.getAttribute('form')]  
   
     return ret  
   
 #regexp for extracting elements from xml  
 patternTXT=r"<\s*txt.*?>(.*?)</txt>"  
 regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL)  
 patternPage=r"<\s*page.*?>(.*?)</page>"  
 regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL)  
   
           
 def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):  
         """Rerender all Links"""  
     ret=""  
       
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource'],search_sub=1)  
   
         for entry in entries:  
         if entry[1].meta_type == 'ECHO_resource':  
             try:              try:
                 entry[1].ECHO_getResourceMD(template="no")   from ECHO_language import *
                                 if "title" in types:  
                                     entry[1].generate_title()  
                                 if "label" in types:  
                                     entry[1].generate_label()  
                 ret+="OK:"+entry[0]+"-- "+entry[1].getTitle().decode('utf-8')+"-- "+entry[1].getTitle().decode('utf-8')+"<br>"  
             except:              except:
                 ret+="Error:"+entry[0]+"<br>"      print "no echo_language"
       class ECHO_language:
                   """ leere Klasse"""
                           pass
                   
         return "<html><body>"+ret+"Rerenderd all links to resources in: "+self.title+"</html></body>"  
   
 def reloadMetaDataFromStorage(self,RESPONSE=None):  
         """copy metadata from the storage to ECHO"""  
         ret=""  
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)  
   
         for resource in resources:  
             x=str(resource[1].copyIndex_meta2echo_resource())+"<br>"  
             ret+=x  
             #print x  
               
   
         if RESPONSE is not None:  
             #RESPONSE.redirect('./manage_main')  
             return "<html><body>"+ret+"</html></body>"  
   
         return ret  
       
 def getRDFDescription(self,linkURL,urn=None,nameDef=None,typeName=None):  
         """rdf"""  
           
         ret=""  
         about="""<RDF:Description RDF:about="%s">"""  
         name="""<ECHONAVIGATION:name>%s</ECHONAVIGATION:name>"""  
         link="""<ECHONAVIGATION:link xlink:href="%s">%s</ECHONAVIGATION:link>"""  
         clickable="""<ECHONAVIGATION:linkClickable>%s</ECHONAVIGATION:linkClickable>"""  
         #link="""<ECHONAVIGATION:link RDF:about="%s"/>"""  
         type="""<ECHONAVIGATION:type>%s</ECHONAVIGATION:type>"""  
             #xlink="""<ECHONAVIGATION:xlink xlink:href="%s"/>"""      
         if not urn:  
             #urn="urn:"+re.sub('/',':',self.absolute_url())  
             urn=self.absolute_url()  
         about2=about%urn  
         if not nameDef:  
             if hasattr(self,'label') and not (self.label==""):  
                 name2=name%self.label  
             elif not self.title=="":  
                 name2=name%self.title  
             else:  
                 name2=name%self.getId()  
   
             name2=re.sub('&','&amp;',name2)  
         else:  
             name2=name%nameDef  
   
         linkURL=re.sub('http:','',linkURL)  
         linkURL2=re.sub('&','&amp;',linkURL)  
         link2=link%(("http:"+linkURL2),("http:"+urllib.quote(linkURL)))  
         clickable2=clickable%"true"  
   
         if not typeName:  
             type2=type%self.meta_type  
         else:  
             type2=type%typeName  
           
         #ret=about2+"\n"+name2+"\n"+link2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"  
         ret=about2+"\n"+name2+"\n"+type2+"\n"+clickable2+"\n</RDF:Description>"  
         return ret  
       
 def getCopyrightsFromForm(self,argv):   
     medias={}  
     partners={}  
     copyrights={}  
       
     copyrightsFinal=[]  
     for arg in argv.keys():  
           
         if arg[0:5]=='media':  
             nm=int(arg[5:])  
             medias[nm]=argv[arg]  
         elif arg[0:5]=='partn':  
             nm=int(arg[5:])  
             partners[nm]=argv[arg]  
         elif arg[0:5]=='copyr':  
             nm=int(arg[5:])  
             copyrights[nm]=argv[arg]  
   
   
   
     copyrightsList=[(medias[nm],partners[nm],copyrights[nm]) for nm in medias.keys()]  
     for copyright in copyrightsList:  
           
         if copyright[2]=='institution0000':  
             copyrightsFinal.append((copyright[0],copyright[1],self.getPartnerCopyright(copyright[1],'')))  
         else:  
             if not copyright[0]=='':  
                 copyrightsFinal.append(copyright)  
                   
   from ECHO_movie import *
   import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
   import xmlrpclib
                           
     return copyrightsFinal  import logging
   
 #List of different types for the graphical linking viewer  #ersetzt logging.info
 viewClassificationListMaster=['view point','area']  def logger(txt,method,txt2):
       """logging"""
       logging.info(txt+ txt2)
   
   
 def checkDiffs(self,metadict):  def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs=""):
         """check differences"""  
   
           """Allegemeine Informationen zu einer ECHO Collection"""
                   
           self.label = label
           self.title=title
           self.description=description
           self.contentType=contentType
           self.responsible=responsible
           self.credits=toList(credits)
           self.weight=weight
   
   import ECHO_resource
   from ECHO_resource import manage_addECHO_resource
           
         def NoneToEmpty(obj):  class ECHO_resource(ECHO_resource.ECHO_resource):
             if obj:      """depricated use class in ECHO_resource.py"""
                 return obj  
             else:  
                 return ""  
   
                   
   class ECHO_partner(Image,Persistent,ECHO_basis):
       """ECHO Partner"""
                   
         diffs={}      meta_type="ECHO_partner"
                   
         tags=self.findTagsFromMapping(self.contentType)      def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):
         self.referencetypes=tags[2]          self.__name__=id
         self.fields=tags[3]          self.title=title
           self.url=url
           self.person=person
           self.email=email
           self.country=country
           self.color=color
           self.precondition=precondition
           self.copyrightType=copyrightType
           data, size = self._read_data(file)
           content_type=self._get_content_type(file, data, id, content_type)
           self.update_data(data, content_type, size)
                   
       manage_options = Image.manage_options+(
           {'label':'Partner Information','action':'ECHO_partner_config'},
           )
           
         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:  
                                           
                     diffs[self.getFieldTag(tags,field)]=0      def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):
             except:          """Change main information"""
                 diffs[self.getFieldTag(tags,field)]=0          self.url=url
           self.person=person
           self.email=email
           self.country=country
           self.color=color
           self.copyrightType=copyrightType
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                                   
         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]()  
           
         if hasattr(self,type+"_template"):      def ECHO_partner_config(self):
             obj=getattr(self,type+"_template")          """Main configuration"""
             return obj()          if not hasattr(self,'url'):
         else:              self.url=""
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)          pt=zptFile(self, 'zpt/ChangeECHO_partner.zpt')
             pt.content_type="text/html"  
             return pt()              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 getTextFromNode(nodename):  
     nodelist=nodename.childNodes  
     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  
   
 class BrowserCheck:  
     """check the browsers request to find out the browser type"""  
       
     def __init__(self, zope):  
     self.ua = zope.REQUEST.get_header("HTTP_USER_AGENT")  
     self.isN4 = (string.find(self.ua, 'Mozilla/4.') > -1) and (string.find(self.ua, 'MSIE') < 0)  
     self.isIE = string.find(self.ua, 'MSIE') > -1  
     self.nav = self.ua[string.find(self.ua, '('):]  
     ie = string.split(self.nav, "; ")[1]  
     if string.find(ie, "MSIE") > -1:  
         self.versIE = string.split(ie, " ")[1]  
     self.isMac = string.find(self.ua, 'Macintosh') > -1  
     self.isWin = string.find(self.ua, 'Windows') > -1  
     self.isIEWin = self.isIE and self.isWin  
     self.isIEMac = self.isIE and self.isMac  
   
   
   
           
 def writeMetadata(url,metadict,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,xmlfrag=None,digiliburlprefix=None):  
     """Einlesen der Metadaten und und erstellen des geaenderten XML file"""  
   
     def updateTextToolNode(tag,value):  
         #print dom,tag,value  
         metanode=dom.getElementsByTagName('texttool')[0]  
         try:  
             nodeOld=metanode.getElementsByTagName(tag)  
         except:  
             nodeOld=None  
               
         if nodeOld:  
             metanode.removeChild(nodeOld[0]).unlink()  
   
         node=dom.createElement(tag)  
         nodetext=dom.createTextNode(value)  
         node.appendChild(nodetext)  
         metanode.appendChild(node)  
   
     if xmlfrag:  
         geturl="""<?xml version="1.0" ?>  
                            <resource type="MPIWG">  
                <meta>  
                 <bib type="Book">  
                         </bib>  
                 </meta>  
                 </resource>"""  
         dom=xml.dom.minidom.parseString(geturl)  
     else:  
         try:  
             geturl=""  
             for line in ECHO_helpers.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+"<br>"+geturl)  
   
       
   
     metanodes=dom.getElementsByTagName('bib')  
   
     if not metanodes:  
         metanodes=dom.getElementsByTagName('archimedes')  
   
     metanode=metanodes[0]  
   
     for metaData in metadict.keys():  
           
         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)  
         try:  
             metanodetext=dom.createTextNode(unicode(metadict[metaData],"utf-8"))  
         except:  
             metanodetext=dom.createTextNode(metadict[metaData].encode('utf-8'))  
         metanodeneu.appendChild(metanodetext)  
         metanode.appendChild(metanodeneu)  
   
   
       
       
       
     if project:  
         updateTextToolNode('project',project)  
   
     if startpage:  
         updateTextToolNode('startpage',startpage)  
   
     if topbar:  
         updateTextToolNode('toptemplate',topbar)  
   
     if thumbtemplate:  
         updateTextToolNode('thumbtemplate',thumbtemplate)  
   
     if xslt:  
         updateTextToolNode('xslt',xslt)  
   
       
     if digiliburlprefix:  
         updateTextToolNode('digiliburlprefix',digiliburlprefix)  
           
     return dom.toxml().encode('utf-8')  manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
                                Kind='ECHO_partner',kind='ECHO_partner')
       
       
 def readMetadata(url):  
     """Methode zum Auslesen der Metadateninformation zu einer Resource  
     Vorerst noch Typ bib"""  
           
     metadict={}  
     try:  
         geturl=""  
         for line in ECHO_helpers.urlopen(url).readlines():  
             geturl=geturl+line  
                   
                   
     except:  def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',
         return (None,"Cannot open: "+url)                      REQUEST=None):
       """
       Add a new ECHO_partner object.
   
     try:      Creates a new ECHO_partner object 'id' with the contents of 'file'.
         dom=xml.dom.minidom.parseString(geturl)      Based on Image.manage_addImage
     except:      """
         return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
     metanode=dom.getElementsByTagName('bib')      id=str(id)
     metadict['bib_type']='Book'      title=str(title)
     if len(metanode)==0:      content_type=str(content_type)
         metanode=dom.getElementsByTagName('archimedes')      precondition=str(precondition)
         metadict['bib_type']='Archimedes'  
                   
       id, title = OFS.Image.cookId(id, title, file)
                   
     if not len(metanode)==0:          self=self.this()
         metacontent=metanode[0].childNodes  
           
         try:      # First, we create the image without data:
             metadict['bib_type']=getText(dom.getElementsByTagName('bib')[0].attributes['type'].childNodes)      self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))
         except:  
             """nothing"""  
                   
         for node in metacontent:      # Now we "upload" the data.  By doing this in two steps, we
             try:      # can use a database trick to make the upload more efficient.
             #print urllib.unquote(getText(node.childNodes)),getText(node.childNodes)      if file:
             metadict[re.sub('-','_',node.tagName.lower())]=urllib.unquote(getText(node.childNodes))          self._getOb(id).manage_upload(file)
             except:      if content_type:
                 """nothing"""          self._getOb(id).content_type=content_type
   
       if REQUEST is not None:
           try:    url=self.DestinationURL()
           except: url=REQUEST['URL1']
           REQUEST.RESPONSE.redirect('%s/manage_main' % url)
       return id
   
     return metadict,""  class ECHO_locale(ZopePageTemplate):
           """localisierung"""
           
           meta_type="ECHO_locale"
   
 def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs,viewClassification=""):          def __init__(self,id,lang,title,label,text=None,content_type=None):
               self.lang=lang
               self.title=title
               self.label=label
               # default content
               if not text:
                   text = open(self._default_content_fn).read()
                   content_type = 'text/html'
               self.pt_edit(text, content_type)
               self.id=id
   
         """Allegemeine Informationen zu einer ECHO Collection"""          manage_options = ZopePageTemplate.manage_options+(
                   {'label':'Main Config','action':'change_ECHO_localeForm'},
                   )
   
         self.viewClassification=viewClassification          def change_ECHO_localeForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_localeForm.zpt')
                   return pt()
   
         self.label = label          def change_ECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
                   """change echo locale"""
                   self.lang=lang
         self.title=title          self.title=title
         self.description=description                  self.label=label
         self.contentType=contentType                  if not text is None:
         self.responsible=responsible                          if content_type is None:
         self.credits=toList(credits)                              content_type = self.content_type
         self.weight=weight                          self.pt_edit(text, content_type)
   
         coords=[]                  if RESPONSE is not None:
         #coordinates of for rectangles                          RESPONSE.redirect('manage_main')
   
                   
         if coordstrs:  def manage_addECHO_localeForm(self):
             for coordstr in coordstrs:           """Form for adding"""
            pt=zptFile(self, 'zpt/AddECHO_localeForm.zpt')
            return pt()
                   
                 try:  def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
                     temco=coordstr.split(",")          """add echo locale"""
                 except:  
                     temco=[]  
                   
                 coords.append(temco)          id="locale_"+lang
   
           self._setObject(id, ECHO_locale(id,lang,title,label,text,content_type))
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
   
         self.coords=coords[0:]  
                           
 class ECHO_copyright(Folder):  class ECHO_copyright(Folder,ECHO_basis):
     """Copyright informationen"""      """Copyright informationen"""
     meta_type="ECHO_copyright"      meta_type="ECHO_copyright"
           
Line 523  class ECHO_copyright(Folder): Line 270  class ECHO_copyright(Folder):
   
     def ECHO_copyright_configForm(self):      def ECHO_copyright_configForm(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_copyright').__of__(self)                  pt=zptFile(self, 'zpt/ChangeECHO_copyright')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
Line 539  class ECHO_copyright(Folder): Line 286  class ECHO_copyright(Folder):
                   
 def manage_addECHO_copyrightForm(self):  def manage_addECHO_copyrightForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_copyright.zpt').__of__(self)      pt=zptFile(self, 'zpt/AddECHO_copyright.zpt')
     return pt()      return pt()
   
 def manage_addECHO_copyright(self, id,title,RESPONSE=None):  def manage_addECHO_copyright(self, id,title,RESPONSE=None):
Line 556  def manage_addECHO_copyright(self, id,ti Line 303  def manage_addECHO_copyright(self, id,ti
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
 class ECHO_layoutTemplate(ZopePageTemplate):  class ECHO_layoutTemplate(ZopePageTemplate,ECHO_basis):
     """Create a layout Template for different purposes"""      """Create a layout Template for different purposes"""
   
     meta_type="ECHO_layoutTemplate"      meta_type="ECHO_layoutTemplate"
Line 564  class ECHO_layoutTemplate(ZopePageTempla Line 311  class ECHO_layoutTemplate(ZopePageTempla
     def __init__(self, id, text=None, content_type=None,EchoType=None):      def __init__(self, id, text=None, content_type=None,EchoType=None):
         self.id = str(id)          self.id = str(id)
   
   
   
         self.ZBindings_edit(self._default_bindings)          self.ZBindings_edit(self._default_bindings)
         if text is None:          if text is None:
             self._default_content_fn = os.path.join(package_home(globals()),              self._default_content_fn = os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%EchoType)
                                                'zpt/ECHO_%s_template_standard.zpt'%EchoType)  
             text = open(self._default_content_fn).read()              text = open(self._default_content_fn).read()
           if content_type is None:
               content_type = self.content_type
         self.pt_edit(text, content_type)          self.pt_edit(text, content_type)
   
           
         """change form"""  
   
   
 def manage_addECHO_layoutTemplateForm(self):  def manage_addECHO_layoutTemplateForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_layoutTemplate.zpt').__of__(self)      pt=zptFile(self, 'zpt/AddECHO_layoutTemplate.zpt')
     return pt()      return pt()
   
 from urllib import quote  
   
   
 def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):  def manage_addECHO_layoutTemplate(self, EchoType,title=None,REQUEST=None):
     "Add a Page Template with optional file content."      "Add a Page Template with optional file content."
Line 624  def manage_addECHO_layoutTemplate(self, Line 365  def manage_addECHO_layoutTemplate(self,
     REQUEST.RESPONSE.redirect(u+'/manage_main')      REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''      return ''
   
 class ECHO_fullText(ZopePageTemplate):  class ECHO_fullText(ZopePageTemplate,ECHO_basis,ECHO_language):
     """echo fulltext in xml"""      """echo fulltext in xml"""
   
     meta_type="ECHO_fullText"      meta_type="ECHO_fullText"
   
     def donatusVariant2Lemma(self,nr='1'):  
         """analyze by donatus"""  
         return donatusVariant2Lemma(donatus(self.lemmatize(nr)))  
   
     def tagLex(self,nr="1"):  
         """generate Links"""  
         global retLex  
         global toggle  
   
         toggle=0  
         retLex=""  
   
         lemmatized=self.lemmatize(nr)[0:]  
         #print "ho",repr(lemmatized)  
         variants=donatusVariant2Lemma(donatus(lemmatized))  
           
         def createTag(name,attrs):  
                         global toggle  
               
             if name=="w":  
                 toggle=1  
                 return ""  
             else:  
                 tag="<"  
                 tag+=name  
                 for attr in attrs.keys():  
                     tag+=""" %s="%s" """%(attr,attrs[attr])  
                 tag+=">"  
             return tag  
                   
         def createData(data):  
             global toggle  
             astring="""<a href="http://141.14.236.86/cgi-bin/toc/dict?step=remotetable;word=%s;lang=de" target="_blank">%s</a> """  
             if toggle: # tag war ein w  
                 toggle=0  
                 if variants.has_key(data):  
                     return astring%(variants[data][0],data)  
                 else:  
                     return astring%(data,data)  
                   
                       
   
         # 3 handler functions  
         def start_element(name, attrs):  
             global retLex  
               
             retLex+=createTag(name,attrs)  
         def end_element(name):  
             global retLex  
             if not name=="w":  
                 retLex+="</%s>"%(name.encode('utf-8'))  
               
               
         def char_data(data):  
             global retLex  
             if data:  
                 try:  
                     retLex+=createData(data)  
                 except:  
                     """no"""  
                       
         p = xml.parsers.expat.ParserCreate()  
   
         p.StartElementHandler = start_element  
         p.EndElementHandler = end_element  
         p.CharacterDataHandler = char_data  
           
         p.Parse(lemmatized.encode('utf-8'),1)  
         #print repr(lemmatized.encode('utf-8'))  
       
         return retLex  
       
           
     def lemmatize(self,nr='1',lang="de"):  
         """lemmatize"""  
         global ret  
         ret=""  
           
         def createTag(name,attrs):  
             tag="<"  
             tag+=name  
             for attr in attrs.keys():  
                 tag+=""" %s="%s" """%(attr,attrs[attr])  
             tag+=">"  
             return tag  
                   
         def insertW(str):  
             splitted=str.split()  
             wordlist=["<w>%s</w>"%split for split in splitted]  
             return string.join(wordlist,'\n')  
   
         # 3 handler functions  
         def start_element(name, attrs):  
             global ret  
             ret+=createTag(name,attrs)  
         def end_element(name):  
             global ret  
             ret+="</%s>"%(name.encode('utf-8'))  
               
         def char_data(data):  
             global ret  
             ret+=insertW(data)  
   
         p = xml.parsers.expat.ParserCreate()  
   
         p.StartElementHandler = start_element  
         p.EndElementHandler = end_element  
         p.CharacterDataHandler = char_data  
   
         p.Parse(self.getPage(nr), 1)  
         txt="""<wtag locator="xxx">  
         <section lang="%s"><s>%s</s></section>  
         </wtag>"""  
         ret=txt%(lang,ret)  
           
         return ret  
           
     def getPage(self,nr='1'):      def getPage(self,nr='1'):
         """get page n"""          """get page n"""
                   #return self().encode('latin-1','ignore')
                   try:
         dom=xml.dom.minidom.parseString(self())          dom=xml.dom.minidom.parseString(self())
                   except:
                      dom=xml.dom.minidom.parseString(self.utf8ify(self()))
         pages=dom.getElementsByTagName('page')          pages=dom.getElementsByTagName('page')
                   
         return pages[int(nr)-1].toxml('utf-8')                  return pages[int(nr)-1].toxml()
           
 # Product registration and Add support  # Product registration and Add support
 manage_addECHO_fullTextForm = PageTemplateFile(  manage_addECHO_fullTextForm = PageTemplateFile(
     'zpt/AddECHO_fullText.zpt', globals())      'zpt/AddECHO_fullText.zpt', globals())
   
 from urllib import quote  
   
 def manage_addECHO_fullText(self, id, title=None, text=None,  def manage_addECHO_fullText(self, id, title=None, text=None,
                            REQUEST=None, submit=None):                             REQUEST=None, submit=None):
     "Add a Page Template with optional file content."      "Add a Page Template with optional file content."
Line 786  def manage_addECHO_fullText(self, id, ti Line 413  def manage_addECHO_fullText(self, id, ti
             u = REQUEST['URL1']              u = REQUEST['URL1']
   
         if submit == " Add and Edit ":          if submit == " Add and Edit ":
             u = "%s/%s" % (u, quote(id))              u = "%s/%s" % (u, urllib.quote(id))
         REQUEST.RESPONSE.redirect(u+'/manage_main')          REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''      return ''
   
 class ECHO_resource(Folder,Persistent):  
     """ECHO Ressource"""  
     security=ClassSecurityInfo()  
     meta_type='ECHO_resource'  
   
     viewClassificationList=viewClassificationListMaster  
   
     getSubCols = ECHO_helpers.getSubCols  
   
     security.declareProtected('View','index_html')  
   
     def showRDF(self):  
         """showrdf"""  
             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
         ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""  
         ret+=self.getRDF(urn="echo:colllectionroot")+"\n"  
   
         ret+="""</RDF:RDF>"""  class ECHO_externalLink(Folder,ECHO_basis):
             return ret       """Link zu einer externen Ressource"""
       security=ClassSecurityInfo()
     def getRDF(self,urn=None):      meta_type='ECHO_externalLink'
         """rdf"""  
         ret=getRDFDescription(self,self.link,urn=urn)  
         return ret+self.createSubElementRDF(urn=urn)   
   
   
     def createSubElementRDF(self,urn=None):  
         """rdf list"""  
         if not urn:  
             urn=self.absolute_url()  
         ret=""  
   
         rettemp="""<RDF:Seq RDF:about="%s">\n"""%urn  
         flag=0  
           
         li="""<RDF:li RDF:resource="%s" />\n"""  
         if not ('<error>' in self.getFullTextXML(noredirect='Yes')):  
             nurn=self.absolute_url()+'/getFullTextXML'  
             rettemp+=li%nurn  
             flag=1  
         if not ('<error>' in self.getImageView(noredirect='Yes')):  
             nurn=self.absolute_url()+'/getImageView'  
             rettemp+=li%nurn  
             flag=1  
   
   
         if not ('<error>' in self.showMetaDataXML()):  
             nurn=self.absolute_url()+'/showMetaDataXML'  
             rettemp+=li%nurn  
             flag=1  
               
         rettemp+="</RDF:Seq>"  
   
         if flag==1:  
             ret+=rettemp  
               
         if not ('<error>' in self.getFullTextXML(noredirect='Yes')):  
                     nurn=self.absolute_url()+'/getFullTextXML'    
             ret+=getRDFDescription(self,self.absolute_url()+'/getFullTextXML',urn=nurn,nameDef="Fulltext",typeName="ECHO_fulltext")  
   
         if not ('<error>' in self.getImageView(noredirect='Yes')):  
                     nurn=self.absolute_url()+'/getImageView'  
             ret+=getRDFDescription(self,self.absolute_url()+'/getImageView',urn=nurn,nameDef="Image View",typeName="ECHO_imageview")  
               
         if not ('<error>' in self.showMetaDataXML()):  
                     nurn=self.absolute_url()+'/showMetaDataXML'  
             ret+=getRDFDescription(self,self.absolute_url()+'/showMetaDataXML',urn=nurn,nameDef="Metadata",typeName="ECHO_metaData")  
   
         return ret  
           
     def getAccessRightSelectorHTML(self,outlook="select"):  
         """htmlselector"""  
         values=['free','mpiwg']  
           
         if outlook=="select":  
             ret="""<select name="%s">"""%self.getId()  
   
             for value in values:  
                 if value==self.getAccessRightMD():  
                     ret+="<option selected>%s</option>"%value  
                 else:  
                     ret+="<option>%s</option>"%value  
             return ret+"</select>"  
   
         else:      security.declarePublic('content_html')
             ret=""      def content_html(self):
             for value in values:          """template fuer content"""
           ret= ECHO_basis.content_html(self,'externalLink')
                                   
                 if value==self.getAccessRightMD():          if type(ret) is StringType:
                     ret+="""<input type="radio" name="%s" value="%s" checked>%s"""%(self.getId(),value,value)              return ret.decode('utf-8')
                 else:                  else:
                     ret+="""<input type="radio" name="%s" value="%s">%s"""%(self.getId(),value,value)  
             return ret              return ret
   
   
           
     def getAccessRightMD(self):      def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType):
         """set accessright"""  
         url=self.metalink  
   
         try:  
             geturl=""  
             for line in ECHO_helpers.urlopen(url).readlines():  
                 geturl=geturl+line  
   
   
         except:  
             return (None,"Cannot open: "+url)  
   
         try:  
             dom=xml.dom.minidom.parseString(geturl)  
             root=dom.getElementsByTagName('resource')[0]  
         except:  
             return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
         internal=dom.getElementsByTagName('internal')          self.id = id
         if internal:          """Festlegen der ID"""
             institution=dom.getElementsByTagName('institution')  
             return getText(institution[0].childNodes)  
                   
         free=dom.getElementsByTagName('free')          self.credits=toList(credits)
         if free:          self.label = label
             return "free"          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
           self.linkType = linkType        # Linktypen 'otherPresentation','external'
   
         return "free" #default free  
   
     def changeAccessRightMD(self,accessright,RESPONSE=None):      def ECHO_externalLink_config(self):
         """change the rights"""          """Main configuration"""
                   
         params="accessright=%s"%accessright          if not hasattr(self,'weight'):
               self.weight=""
           if not hasattr(self,'coords'):
   
               self.coords=['']
   
         #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()  
   
           pt=zptFile(self, 'zpt/ChangeECHO_externalLink.zpt')
           return pt()
                   
         ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/setAccessRightXML'+urllib.quote('?'+params))).read()  
   
       def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
           """Aenderung der Properties"""
           setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
               
           self.link=link
           self.linkType = linkType
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
       def getLinkType(self):
           """ return linkType """
           if hasattr(self,"linkType"):
                   return self.linkType
           else :
                   return 'otherPresentation'
                   
     def setAccessRightXML(self,accessright):      def setLinkType(self,type):
         """set accessright"""          """ set linkType """
         url=self.metalink          self.linkType = type
   
         try:  
             geturl=""  
             for line in ECHO_helpers.urlopen(url).readlines():  
                 geturl=geturl+line   
   
   
         except:  
             return (None,"Cannot open: "+url)  
   
       def checkLink(self):
           """ returns tuple (isWorking,Error) """        
         try:          try:
             dom=xml.dom.minidom.parseString(geturl)              urllib2.urlopen(self.link)
             root=dom.getElementsByTagName('resource')[0]              return (True, '')
           except urllib2.HTTPError, e:
               return (False, e.code)
           except urllib2.URLError, e:
               return (False, str(e.reason))
         except:          except:
             return (None,"Cannot parse: "+url+"<br>"+geturl)              return (False, 'unknown Error')
   
         metanodes=dom.getElementsByTagName('access-conditions')  
   
         if not metanodes:  
             nodenew=dom.createElement('access-conditions')  
             root.appendChild(nodenew)  
             metanode=nodenew  
         else:  
             metanode=metanodes[0]  
   
         accesses=metanode.getElementsByTagName('access')  
   
         if not accesses:  
             nodenew2=dom.createElement('access')  
             metanode.appendChild(nodenew2)  
             metanode2=nodenew2  
         else:  
             metanode2=accesses[0]  
   
         internal=metanode.getElementsByTagName('internal')  
   
         if internal:  
             metanode2.removeChild(internal[0]).unlink()  
   
         free=metanode.getElementsByTagName('free')  
           
         if free:  
             metanode2.removeChild(internal[0]).unlink()  
   
       manage_options = (
           {'label':'Main Config','action':'ECHO_externalLink_config'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
           )+Folder.manage_options
   
         if accessright=='free':  
             nodenew3=dom.createElement('free')  
             metanode2.appendChild(nodenew3)  
         elif accessright=='mpiwg':  
             nodenew3=dom.createElement('internal')  
             nodenew4=dom.createElement('institution')  
             metanodetext=dom.createTextNode('mpiwg')  
             nodenew4.appendChild(metanodetext)  
             nodenew3.appendChild(nodenew4)  
             metanode2.appendChild(nodenew3)  
   
         return dom.toxml().encode('utf-8')      def index_html(self):
           """standard page"""
   
     def setStartPageForm(self):          return self.REQUEST.RESPONSE.redirect(self.link)
         """Form for changing the startpage"""  
   
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resourceStartPage.zpt').__of__(self)  def manage_addECHO_externalLinkForm(self):
             pt.content_type="text/html"          """Form for external Links"""
           pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')
             return pt()              return pt()
           
           
     def setStartPage(self,startpage=None,RESPONSE=None):  def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
         """set start page, if no startpage defined use the generic one of the resource"""      """Add an external Link"""
   
         if (not (type(startpage)==StringType)) and ("__generic" in startpage): # checke ob generic in der liste  
             startpage=self.absolute_url()+"/startpage_html"  
               
         if (not startpage) or (startpage=="__generic"):  
              startpage=self.absolute_url()+"/startpage_html"  
           
       
         params="startpage=%s"%startpage  
           
         ECHO_helpers.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'+urllib.quote('?'+params))).read()  
       
           
         path=self.metalink  
           
         path=re.sub(self.REQUEST['SERVER_URL'],'',path)  
         path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)  
   
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server  
         path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server  
             path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server  
         path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server  
         path=re.sub('http://vision.rz-berlin.mpg.de','',path) # falls vision als server  
         path=re.sub('/index.meta','',path)   
   
       newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
   
         ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()      self._setObject(id,newObj)
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def changeViewerTemplateSetForm(self):  
         """change the viewer template set"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeResourceViewerTemplateSet').__of__(self)  
             return pt()  
   
   
     def getTextToolsField(self,name,default=''):  
         """Lese Textoolsfelder aus index.meta im path aus"""  
           
         try:  
             dom=xml.dom.minidom.parse(self.metalink)  
             node=dom.getElementsByTagName('texttool')[0] #getNode  
             subnode=node.getElementsByTagName(name)[0]  
   
             # bei text wird nur der Folder gebraucht  
             if name=="text":  
                 splitted=getText(subnode.childNodes).split("/")  
                 return splitted[len(splitted)-2]  
             else:  
                 return getText(subnode.childNodes)  
         except:  
             return default  
      
   
     def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):  
         """changeit"""  
   
         paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']  
   
                   
         #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)  class ECHO_link(ECHO_externalLink):
           """external_link"""
         params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)  
   
           
         ECHO_helpers.urlopen('http://echo.mpiwg-berlin.mpg.de/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()  
   
         #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)  
         # hack Pfad auf die Dokumente  
         path=self.metalink  
           
           
   
         path=re.sub('/index.meta','',path)   
   
         path=re.sub(self.REQUEST['SERVER_URL'],'',path)  
         path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)  
   
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server  
   
         path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server          meta_type="ECHO_link"
         path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server  
         path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server  
   
         path=re.sub('http://vision.rz-berlin.mpg.de','',path) # falls vision als server          manage_options = ECHO_externalLink.manage_options+(
                   {'label':'add links config','action':'ECHO_link_addLinksForm'},
                   )
   
         return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()          def ECHO_link_addLinksForm(self):
               """Main configuration"""
   
               pt=zptFile(self, 'zpt/ChangeECHO_link_addLinks.zpt')
               return pt()
   
           def ECHO_link_addLinks(self,addLinks,RESPONSE):
               """add links"""
               self.addLinks=addLinks
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
       
     def getTitle(self):  
     """title"""  
     try:  
         return self.title.encode('utf-8','ignore')   
     except:  
         self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.title.encode('utf-8','ignore')   
       
     def getLabel(self):  
     """title"""  
     try:  
         return self.label.encode('utf-8','ignore')   
     except:  
         self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.label.encode('utf-8','ignore')   
       
     def content_html(self):      def content_html(self):
         """template fuer content"""                  """template fuer link"""
         return content_html(self,'resource')  
       
     def getViewClassification(self):  
         if hasattr(self,'viewClassification'):  
             return self.viewClassification  
         else:  
             return ""  
   
     def getFullTextXML(self,noredirect=None):  
         """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""  
         try:  
             fh=ECHO_helpers.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.setHeader('Content-Type','text/xml')    
                 self.REQUEST.RESPONSE.redirect(texturl)  
             else:  
                 return texturl  
         except:  
   
             if not noredirect:  
                 self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
                 self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")  
             else:  
                 return "<error>no fulltext available</error>"  
   
   
     def getImageView(self,noredirect=None):  
         """getImages; give Imageviewr  and <error></error> if somthing goes wrong."""  
         try:  
             fh=ECHO_helpers.urlopen(self.metalink)  
             dom=xml.dom.minidom.parse(fh)  
             texttools=dom.getElementsByTagName('texttool')  
             text=texttools[0].getElementsByTagName('image')  
             imagetemp=getText(text[0].childNodes)  
                           
             text=dom.getElementsByTagName('archive-path')                  if hasattr(self,"link_template"):
             archivepath=getText(text[0].childNodes)                          ret=ECHO_basis.content_html(self,'link')
             archivepath=re.sub('/mpiwg/online/','',archivepath)   
             imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp  
             if not noredirect:  
                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')    
                 self.REQUEST.RESPONSE.redirect(imageurl)  
             else:  
                 return imageurl  
         except:  
   
             if not noredirect:  
                 self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
                 self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")  
             else:              else:
                 return "<error>no images available</error>"                          ret=ECHO_basis.content_html(self,'collection')
   
           
                   #return ret
                   return ret
   #            
   #            
   #                try:
   #                    return ret.decode('utf-8')
   #                except:
   #                    try: 
   #                        return ret.decode('latin-1')
   #                    except:
   #                
   #                        return ret
   #        
     def getCopyrightsHTML(self):      def getCopyrightsHTML(self):
         """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""          """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
                   
Line 1214  class ECHO_resource(Folder,Persistent): Line 613  class ECHO_resource(Folder,Persistent):
         return ret          return ret
                   
     def getInstitutionsHTML(self):      def getInstitutionsHTML(self):
         """gibt Liste der fšrdernden Institutionen aus"""                  """gibt Liste der foerdernden Institutionen aus"""
                   
         if hasattr(self,'support'):          if hasattr(self,'support'):
             obj=self.support              obj=self.support
Line 1223  class ECHO_resource(Folder,Persistent): Line 622  class ECHO_resource(Folder,Persistent):
         else:          else:
             return ''              return ''
                           
           def getOwnerOriginalsHTML(self):
                  """gibt Liste der foerdernden Institutionen aus"""
           
     def getCredits(self):                 if hasattr(self,'ownerOriginal'):
         """Ausgabe der credits"""                         obj=self.ownerOriginal
         if self.credits:                         ret=obj.getOwner()
             return self.credits                         return ret
         else:          else:
             return []                         return ''
       
     def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):  
   
         self.id = id  
         """Festlegen der ID"""  
                   
         self.label = label          def getDigiCopyByHTML(self):
         self.link= link                 """gibt Liste der foerdernden Institutionen aus"""
         self.metalink=metalink  
         self.title=title  
         self.weight=weight  
         self.credits=toList(credits)  
         self.description=description  
         self.contentType=contentType  
     self.copyrightType=copyrightType  
     self.renderingType=renderingType  
         self.responsible=responsible  
         self.resourceID=resourceID  
           
         if coords:                 if hasattr(self,'digiCopyBy'):
             coordsnew=[ string.split(x,",") for x in coords]                         obj=self.digiCopyBy
                          ret=obj.getDigiCopyBy()
                          return ret
         else:          else:
             coordsnew=[]                         return ''
                   
         self.coords=coordsnew          def index_html(self):
                   """standard link"""
                   if self.link:
                    splitted=self.link.split("?")
                    if len(splitted)>1:
                           params=cgi.parse_qs(splitted[1])
   
                           for x in params.keys():
                                   if type(params[x]) is ListType:
                                           params[x]=params[x][0]
   
     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  
   
                    else:
                           params={}
           
                    if getattr(self,'addLinks','yes')=="yes":
                        params['backLink']=self.aq_parent.absolute_url()
                        params['startLink']=splitted[0]+"?"+urllib.urlencode(params)
   
     def getContentType(self):  
         try:  
             return self.contentType  
         except:  
             return ""  
   
     def getCopyrightType(self):                   return self.REQUEST.RESPONSE.redirect(splitted[0]+"?"+urllib.urlencode(params))
         try:                  else:
             return self.copyrightType  
         except:  
             return ""  
   
     def getRenderingType(self):  
         try:  
             return self.renderingType  
         except:  
             return ""              return ""
   
     def ECHO_resource_config(self):  def manage_addECHO_linkForm(self):
         """Main configuration"""          """Form for external Links"""
           pt=zptFile(self, 'zpt/AddECHO_linkForm.zpt')
         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.meta  
                         DataHash[data_neu]=getattr(self,data)[0:]  
   
       
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)  
         return pt()          return pt()
   
   
   def manage_addECHO_link(self,id,title,label,description="",contentType="",responsible="",link="",weight="",coords=[],credits=None,linkType="external",RESPONSE=None):
       """Add an external Link"""
           
       newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
   
     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):      self._setObject(id,newObj)
         """Ä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_local(self,RESPONSE=None):  
         """change metadata"""  
         tags=self.findTagsFromMapping(self.contentType)  
         for field in tags[1]:  
             self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]  
               
   
                   
         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"""  
   
         ECHO_helpers.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 getMDValue(self,fieldName):  
         return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)  
                        
     def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):  
         """new index.meta"""  
         self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
   
         if not hasattr(self,'metaDataHash'):  
           
             self.copyIndex_meta2echo_resource()  
         try:  
             return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)  
         except:  
             return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)  
   
     def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):  
         """schreibe md"""  
           
         try:  
               
             return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")  
         except:  
             return "<error> no metadata stored</error>"  
       
     def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):  
         """prints out metadata as stored in the echo environment, format is the index.meta format"""  
         self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
         return writeMetadata(self.metalink,self.metaDataHash)  
   
     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)      getattr(self,id).addLinks='no'
     self.viewClassification=viewClassification  
         self.coords=coordsnew[0:]  
         self.link=link  
         self.metalink=metalink  
                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
                           
     manage_options = Folder.manage_options+(  class ECHO_collection(CatalogAware, Folder, Persistent, Implicit, Cacheable,ECHO_basis):
         {'label':'Main Config','action':'ECHO_resource_config_main'},      """ECHO Collection"""
     {'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'},  
     {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},  
     {'label':'set/change startpage','action':'setStartPageForm'},  
     {'label':'Copy MD for indexing and search','action':'copySearchFields'},  
     )  
   
     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"""  
       
         try:  
       
             ret=self.metaDataHash[field]  
             if ret == "":  
                 return None  
             else:  
                 return ret  
         except:  
             return None  
   
     def getMetaDataHash(self):  
         """md hash"""  
         return self.metaDataHash  
       
     def setFieldValue(self,field,value):  
         """get value"""  
       
     if not hasattr(self,'metaDataHash'):  
         setattr(self,'metaDataHash',{})  
     self.metaDataHash[field]=value[0:]  
       
   
     def copySearchFields(self):  
         """copys metadatafields to the object"""  
         fields=['author','title','year']  
         for field in fields:  
             setattr(self,'MD_'+field,self.getFieldValue(field))  
       
   
     def findLabelsFromMapping(self,referenceType):  
         """gib hash mit label -> generic zurueck"""  
     #return {},[]  
   
         temp=self.ZopeFind(self.standardMD)  
   
     if referenceType=="":  
         referenceType="book"  
       
       
         bibdata={}  
         retdata={}  
     fields=[]  
         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]  
             fields=bibdata[referenceType]  
                         for field in fieldlist:  
                             retdata[field]=referenceTypeF[1].getValue(field)[1]  
   
         return retdata,fieldlist,temp,fields  
   
     def findTagsFromMapping(self,referenceType):  
         """gib hash mit label -> generic zurueck"""  
       
   
     if referenceType=="":  
         referenceType="book"  
       
     temp =  self.ZopeFind(self.standardMD)[0:]  
   
       
     #self.referencetypes=temp[0:]  
       
       
       
   
       
   
         bibdata={}  
         retdata={}  
         fieldlist=self.standardMD.fieldList  
         fields=[]  
     for referenceTypeF in temp:  
         #print referenceType  
       
         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]  
             fields=bibdata[referenceType]  
                         for field in fieldlist:  
                             retdata[field]=referenceTypeF[1].getValue(field)[0]  
       
         return retdata,fieldlist,temp,fields  
   
       
     security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination  
     def copyIndex_meta2echo_resource(self,RESPONSE=None):  
         """copy MD von Index_meta to the echo_resource"""  
           
         (metadict, error)=readMetadata(self.metalink)  
   
   
           
         self.metaDataHash={}  
         if not error=="": #Fehler beim Auslesen des Metafiles  
               
             return "ERROR:",error,self.absolute_url()  
           
         self.contentType=metadict['bib_type'][0:]  
         fields=self.findTagsFromMapping(self.contentType)  
           
         #fields=self.findLabelsFromMapping(self.contentType)  
         for field in fields[1]:  
               
             if self.isDefinedInThisSet(fields,field):  
                 #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))  
                 self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))  
   
           
           
         if RESPONSE:  
             return RESPONSE.redirect('manage_main')  
           
     def ECHO_getResourceMD(self,template="yes",back=None):  
         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""  
         (metadict, error)=readMetadata(self.metalink)  
   
         if back:  
             self.REQUEST.SESSION['back']=back  
   
         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,self.REQUEST.SESSION['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 startpage_html(self):  
         """prints out a startpage for a resource for use e.g. in the BVE"""  
   
         # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt  
   
         sp=self.ZopeFind(self,obj_ids=['startpage.html'])  
   
         if sp:      management_page_charset="utf-8"
             return sp[1]()      security=ClassSecurityInfo()
       meta_type='ECHO_collection'
       default_catalog='resourceCatalog'
   
             #prĂźfen ob irgendwo ein template  #    viewClassificationList=viewClassificationListMaster
         if hasattr(self,'startpage_index_template'):       displayTypes=displayTypes
             return self.startpage_index_template()  
   
         #generisches template ausgeben      path="/mpiwg/online/permanent/shipbuilding"
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_startpage_index_template_standard.zpt').__of__(self)      def getSection(self, crumbs=None):
           """returns the current section name"""
           # use breadcrumbs if available
           if crumbs is not None and len(crumbs) > 0:
               return crumbs[0][2].getId()
       
           p = self
         
           sec = None
           # descend parents to the root (and remember the last id)
           while p is not None and p.meta_type != 'ECHO_root' and p.meta_type!='ECHO_main' and p.meta_type!='ECHO_nav':
               sec = p.getId()
               p = p.aq_parent
        
           return sec
       
       def getSubSection(self, crumbs=None):
           """returns the current subsection name"""
           # use breadcrumbs if available
           if crumbs is not None and len(crumbs) > 1:
               return crumbs[1][2].getId()
       
           p = self
           sec = None
           subsec = None
           # descend parents to the root (and remember the last id)
           while p is not None and p.meta_type != 'ECHO_root' and p.meta_type!='ECHO_main' and p.meta_type!='ECHO_nav':
               subsec = sec
               sec = p.getId()
               p = p.aq_parent
             
           return subsec
   
       
       def exportImportObjects_html(self,RESPONSE):
           """ImportObject"""
           pt=zptFile(self, 'zpt/exportImportObjects.zpt')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
     def toc_html(self):      def importObjects_html(self,RESPONSE):
                   """ImportObject"""
         sp=self.ZopeFind(self,obj_ids=['toc.html'])          pt=zptFile(self, 'zpt/importObjects.zpt')
                       pt.content_type="text/html"
         if sp:  
             return sp[0][1]()  
   
   
     security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination  
   
     def generate_label(self):  
         """Erzeugt_standard_Label aus Template"""  
         pt=getattr(self,"label_template_"+self.contentType.lower())  
   
     self.label=pt()[0:]  
         return pt()  
   
     security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination  
   
     def generate_title(self,RESPONSE=None):  
         """Erzeugt_standard_Label aus Template"""  
         pt=getattr(self,"label_template_"+self.contentType.lower())  
   
     self.title=pt()[0:]  
       
         return pt()  
   
 Globals.InitializeClass(ECHO_resource)  
   
 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,responsible,link,metalink,weight,copyrightType=None,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):  
     """addaresource"""  
   
     newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,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"""  
     try:  
         return self.title.encode('utf-8','ignore')   
     except:  
         self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.title.encode('utf-8','ignore')   
       
     def getLabel(self):  
     """title"""  
     try:  
         return self.label.encode('utf-8','ignore')   
     except:  
         self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.label.encode('utf-8','ignore')   
   
     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=['']  
   
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)  
         return pt()          return pt()
           
       def importObjects(self,zfile,RESPONSE=None,REQUEST=None):
           """import object from file"""
   
     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):          zf=zipfile.ZipFile(zfile,"r")
           tmpdir=tempfile.mkdtemp() # create tempdir
         """Änderung der Properties"""          ret=None
           
           for name in zf.namelist():
                  ds,fn=tempfile.mkstemp()
                  tf=file(fn,"w")
                  x=zf.read(name)
                  tf.write(x)
                  tf.close()
     try:      try:
         coordsnew=[ string.split(x,",") for x in coords]                     self._importObjectFromFile(fn,set_owner=1)
     except:      except:
         coordsnew=[]                     if not ret:
                          ret=""
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)                     ret+="Cannot import: %s (Already existing?)<br>"%name
              os.close(ds)
         self.coords=coordsnew[0:]                 os.remove(fn)
         self.link=link  
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
               
               
     manage_options = Folder.manage_options+(  
         {'label':'Main Config','action':'ECHO_externalLink_config'},  
         )  
   
           zf.close()
                   
     def index_html(self):          if ret:
         """standard page"""              return """<html><body>%s</body></html>"""%ret
           if RESPONSE:
               RESPONSE.redirect(self.absolute_url())
                   
         return self.REQUEST.RESPONSE.redirect(self.link)      def exportObjects_html(self,RESPONSE):
           """Export objects"""
   
 def manage_addECHO_externalLinkForm(self):          pt=zptFile(self, 'zpt/exportObjects.zpt')
         """Form for external Links"""          pt.content_type="text/html"
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)  
         return pt()          return pt()
   
       def exportObjects(self,ids,RESPONSE=None):
           """export objects with type id"""
           if not (type(ids) is ListType):
               ids=[ids]
   
 def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):          tmpdir=tempfile.mkdtemp() # create tempdir
     """Add an external Link"""          objs=self.ZopeFind(self,obj_ids=ids)
           tmpfile=tempfile.mkstemp()[1]
   
     newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)          zf=zipfile.ZipFile(tmpfile,"w")
           for obj in objs:
   
     self._setObject(id,newObj)              f = os.path.join(tmpdir, '%s.zexp' %obj[0])
               #print E.absolute_url()
   
     if RESPONSE is not None:              obj[1]._p_jar.exportFile(obj[1]._p_oid, f)
         RESPONSE.redirect('manage_main')  
     
               zf.write(f,obj[0])
   
 class ECHO_link(ECHO_externalLink):          zf.close()
     """external_link"""          shutil.rmtree(tmpdir)
           if RESPONSE:
               RESPONSE.setHeader("Content-Type","application/octet-stream")
               len=os.stat(tmpfile)[6]
               RESPONSE.setHeader("Content-Length",len)
               RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"export.zip")
               fh=file(tmpfile)
               for x in fh.read():
                   RESPONSE.write(x)
               fh.close()
               
       def getMDValueSimpleSearchField(self):
             """returns value for simple search"""
             return " ".join([self.title,self.description])
                                
       def getTitleAndLabel(self):
           """gibt title und label zurueck"""
           return (getattr(self,'title',''),getattr(self,'label',''))
   
       def localizeObjects(self):
               """localize all objects"""
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_externalLink','ECHO_link','ECHO_mapText'])
   
               find=self.ZopeFind(self,obj_ids=('locale_en'))
               if not find:
                   self.manage_addECHO_locale("en",'','')
               for content in contents:
   
     meta_type="ECHO_link"                      if content[1].meta_type in ['ECHO_link','ECHO_externalLink']:
           
                               find=content[1].ZopeFind(content[1],obj_metatypes=('ECHO_mapText'))
                               if find:
                                       root=find[0][1]
   
     def content_html(self):                                      locale=find[0][1].ZopeFind(find[0][1],obj_ids=('locale_en'))
         """template fuer link"""  
         if hasattr(self,"link_template"):  
             return content_html(self,'link')  
         else:          else:
             return content_html(self,'collection')                                      root=None
                       else:
                               root=content[1]
                               locale=content[1].ZopeFind(content[1],obj_ids=('locale_en'))
                       if root and not locale:
                               root.manage_addECHO_locale("en",'','')
           
 def manage_addECHO_linkForm(self):              pt=zptFile(self, 'zpt/localizeObjects.zpt')
         """Form for external Links"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)  
         return pt()          return pt()
   
   
 def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):      def localize(self,REQUEST,RESPONSE):
     """Add an external Link"""              """localize"""
               for key in REQUEST.form.keys():
                       splitted=key.split("!")
   
     newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)                      if splitted[0]=="" or splitted[0]=="en" or splitted[0]=="title" or splitted[0]=="label":
                               if splitted[0]=="en":
                                       setattr(self.locale_en,splitted[1],REQUEST.form[key])
                               else:
                                       setattr(self,splitted[0],REQUEST.form[key])
                       else:
                               obj=getattr(self,splitted[0])
   
     self._setObject(id,newObj)                              if obj.meta_type=="ECHO_mapText":
                                       if splitted[1]=="en":
                                               obj.locale_en.pt_edit(REQUEST.form[key],obj.locale_en.content_type)
                                       else:
                                               obj.pt_edit(REQUEST.form[key],obj.content_type)
                               else:
                                       text=obj.ZopeFind(obj,obj_metatypes=['ECHO_mapText'])
                                       if splitted[1]=="en":
   
                                               text[0][1].locale_en.pt_edit(REQUEST.form[key],text[0][1].locale_en.content_type)
                                       else:
                                               text[0][1].pt_edit(REQUEST.form[key],text[0][1].content_type)
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
   
 class ECHO_collection(Folder, Persistent, Implicit, Cacheable):  
     """ECHO Collection"""  
   
     security=ClassSecurityInfo()  
     meta_type='ECHO_collection'  
     viewClassificationList=viewClassificationListMaster  
     displayTypes=displayTypes  
   
     path="/mpiwg/online/permanent/shipbuilding"  
   
     def getRDF(self,urn=None):      def getRDF(self,urn=None):
         """rdf of the collection"""          """rdf of the collection"""
                   
Line 1916  class ECHO_collection(Folder, Persistent Line 886  class ECHO_collection(Folder, Persistent
         if not urn:          if not urn:
             urn=self.absolute_url()              urn=self.absolute_url()
                           
         li="""<RDF:li RDF:resource="%s" />\n"""              li="""<rdf:li rdf:resource="%s" />\n"""
   
                   
         for content in contents:          for content in contents:
           try:
             ret+=content[1].getRDF()+"\n"              ret+=content[1].getRDF()+"\n"
                               except:
         ret+="""<RDF:Seq RDF:about="%s">\n"""%urn              logging.error("getrdf: "+repr(content[1].getRDF()))
               try:
                   ret+=self.unicodify(content[1].getRDF())+"\n"
               except:
               logging.error("--still cannot do it")
                   ret+=repr(content[1].getRDF())+"\n"
               ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
         for content in contents:          for content in contents:
             nurn=content[1].absolute_url()              nurn=content[1].absolute_url()
             ret+=li%nurn              ret+=li%nurn
         return ret+"</RDF:Seq>"              return ret+"</rdf:Seq>"
           
          
     def showRDF(self):  
         """showrdf"""  
             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
         ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""  
         ret+=self.getRDF(urn="echo:collectionroot")+"\n"  
   
         ret+="""</RDF:RDF>"""  
           
             return ret   
   
   
           
     def changeLabels(self):      def changeLabels(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeLabelsForm').__of__(self)                  pt=zptFile(self, 'zpt/changeLabelsForm')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
     def changeTitles(self):      def changeTitles(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeTitleForm').__of__(self)                  pt=zptFile(self, 'zpt/changeTitleForm')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
     def changeWeights(self):      def changeWeights(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeWeightForm').__of__(self)                  pt=zptFile(self, 'zpt/changeWeightForm')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
     def changeMetaDataLinks(self):      def changeMetaDataLinks(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeMetaDataLinkForm').__of__(self)                  pt=zptFile(self, 'zpt/changeMetaDataLinkForm')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
               
       def changeAccessRightsCollectionForm(self,preselect=None):
           """change access rights of all resources in this collection"""
   
           pt=zptFile(self, 'zpt/changeAccessRightsCollectionForm')
           pt.content_type="text/html"
           return pt(preselect=preselect)
           
           
     def changeAccessRightsCollection(self):      def changeAccessRightsCollection(self):
         """change"""          """change"""
         ret=""          ret=""
Line 1972  class ECHO_collection(Folder, Persistent Line 947  class ECHO_collection(Folder, Persistent
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])          resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
         for resource in resources:          for resource in resources:
                         
             try:                      if argv.has_key(resource[1].getId()+'_xml'):
                 ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"                              ret+=resource[1].getId()+"   "+argv[resource[1].getId()+'_xml']+"</br>"
                 resource[1].changeAccessRightMD(argv[resource[1].getId()])                              resource[1].setAccessRightXML(argv[resource[1].getId()+'_xml'])
             except:                              resource[1].accessRight=argv[resource[1].getId()+'_xml']
                 """not"""                      elif argv.has_key(resource[1].getId()+'_echo'):
                               ret+="only local:"+resource[1].getId()+"   "+argv[resource[1].getId()+'_echo']+"</br>"
                               resource[1].accessRight=argv[resource[1].getId()+'_echo']
                       else:
                               ret+="ERROR:" +resource[0]
         return ret          return ret
   
     def changeMetaDataLinkInCollection(self):      def changeMetaDataLinkInCollection(self):
Line 1991  class ECHO_collection(Folder, Persistent Line 970  class ECHO_collection(Folder, Persistent
                 ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"                  ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                             resource[1].metalink=argv[resource[1].getId()][0:]                              resource[1].metalink=argv[resource[1].getId()][0:]
             except:              except:
                 """not"""                              pass
         return ret          return ret
   
     def changeMetaDataLinkInCollection(self):      def changeMetaDataLinkInCollection(self):
Line 2006  class ECHO_collection(Folder, Persistent Line 985  class ECHO_collection(Folder, Persistent
                 ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"                  ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                             resource[1].metalink=argv[resource[1].getId()][0:]                              resource[1].metalink=argv[resource[1].getId()][0:]
             except:              except:
                 """not"""                              pass
         return ret          return ret
   
     def changeWeightsInCollection(self):      def changeWeightsInCollection(self):
Line 2014  class ECHO_collection(Folder, Persistent Line 993  class ECHO_collection(Folder, Persistent
         ret=""          ret=""
         argv=self.REQUEST.form          argv=self.REQUEST.form
                   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         for resource in resources:          for resource in resources:
                         
             try:              try:
                 ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"                  ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                             resource[1].weight=argv[resource[1].getId()][0:]                              resource[1].weight=argv[resource[1].getId()][0:]
             except:              except:
                 """not"""                              pass
         return ret          return ret
   
     def changeTitlesInCollection(self):      def changeTitlesInCollection(self):
Line 2029  class ECHO_collection(Folder, Persistent Line 1008  class ECHO_collection(Folder, Persistent
         ret=""          ret=""
         argv=self.REQUEST.form          argv=self.REQUEST.form
                   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         for resource in resources:          for resource in resources:
                         
             try:              try:
                 ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"                  ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                             resource[1].title=argv[resource[1].getId()][0:]                              resource[1].title=argv[resource[1].getId()][0:]
             except:              except:
                 """not"""                              pass
         return ret          return ret
                   
     def updateCollection(self,RESPONSE=None):      def changeLabelsInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].label=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
          
       def importCollection(self,path=None,viewerUrl=None,metaDataUrl=None,replacePathPermanent=None,replacePathExperimental=None,RESPONSE=None):
         """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""          """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
         files=os.listdir(self.path)          
           if path is None:
                   pt=zptFile(self, 'zpt/importCollection.zpt')
                   return pt()
   
           files=os.listdir(path)
     ret=""      ret=""
         for fileName in files:          for fileName in files:
                           
             if fileName:              if fileName:
                   
         tempPath=re.sub("/mpiwg/online","",self.path)                  if (replacePathExperimental and replacePathExperimental!=''):
         link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"                      path=re.sub(replacePathExperimental,"/mpiwg/online/experimental",path)
                      
                   if (replacePathPermanent and replacePathPermanent!=''):
                       path=re.sub(replacePathPermanent,"/mpiwg/online/permanent",path)
                   
         metalink=self.path+"/"+fileName+"/index.meta"                  link=viewerUrl%(path+"/"+fileName+"/pageimg")
                   
                   metalink=metaDataUrl+"/"+path+"/"+fileName+"/index.meta"
                 try:                  try:
   
             #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"              #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"
                           
             newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'generated','book','','','','','','')                          newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'','book','','','','','','')
             self._setObject(fileName,newObj)              self._setObject(fileName,newObj)
                                   
             genObj=getattr(self,fileName)              genObj=getattr(self,fileName)
Line 2070  class ECHO_collection(Folder, Persistent Line 1074  class ECHO_collection(Folder, Persistent
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def updateCollectionMD(self,RESPONSE=None):  
         """updateMD"""  
         files=os.listdir(self.path)  
         for fileName in files:  
             if fileName:  
                 genObj=getattr(self,fileName)  
                 genObj.copyIndex_meta2echo_resource()  
                 genObj.generate_title()  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
   
   
     def changeViewerTemplateSetsForm(self):      def changeViewerTemplateSetsForm(self):
         """change the viewer template set"""          """change the viewer template set"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeViewerTemplateSet').__of__(self)              pt=zptFile(self, 'zpt/changeViewerTemplateSet')
             return pt()              return pt()
   
     def getViewerTemplateSets(self,obj_ids=None):      def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):
         """Get the ViewerTemplateSet title for configuration"""          """Get the ViewerTemplateSet title for configuration"""
         ret=[]          ret=[]
                   
Line 2111  class ECHO_collection(Folder, Persistent Line 1101  class ECHO_collection(Folder, Persistent
   
                           
     def isSelectedViewerTemplateSet(self,obj,id):      def isSelectedViewerTemplateSet(self,obj,id):
         """is ausgewählt"""          """is ausgewaehlt"""
                   
         if self.REQUEST['viewerTemplateSet']==id:          if self.REQUEST['viewerTemplateSet']==id:
             return 1              return 1
         else:          else:
             return None              return None
   
       def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):
           """changes all ressources to the newViewer"""
           
           resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
           if RESPONSE is not None:
                       RESPONSE.write("<html><body>")
   
           for resource in resources:
               
               done,msg=resource[1].changeViewer(newViewer)
               if done:
                   if RESPONSE is not None:
                       RESPONSE.write("<p>OK: %s"%resource[0])
               else:
                   if RESPONSE is not None:
                       RESPONSE.write("<p><a href='%s'>ERROR: %s (%s)</a>"%(resource[1].absolute_url()+'/ECHO_resource_config_main',resource[0],msg))
                   
   
                   
           if RESPONSE is not None:
                       RESPONSE.write("<p>Done</p></body></html>")
   
     def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):      def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
         """change the templates"""          """change the templates"""
   
Line 2131  class ECHO_collection(Folder, Persistent Line 1143  class ECHO_collection(Folder, Persistent
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def setStartpageFolderForm(self):  
         """Form for changing the startpage"""  
   
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resourceStartPageFolder.zpt').__of__(self)      def copyTitleToInfoXMLFolder(self,RESPONSE=None):
             pt.content_type="text/html"              """copy title into the title field of info.xml
             return pt()              author and date werden leer!!!
               """
           
     def setStartpageFolder(self,startpage=None,RESPONSE=None):  
         """change the templates"""  
   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)          resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
         for resource in resources:  
   
             resource[1].setStartPage(startpage)              for resource in resources:
                       ret,txt=resource[1].copyTitleToInfoXML()
                       if (not ret) and RESPONSE:
                               RESPONSE.write("error: %s\n"%txt)
                       if ret and RESPONSE:
                               RESPONSE.write("ok: %s\n"%txt)
   
                       #logger("ECHO (copyTitleToInfoXMLFolder)",logging.INFO,txt)   
         if RESPONSE is not None:          if RESPONSE is not None:
                       RESPONSE.write("done!\n")
                       RESPONSE.close()
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
   
     def copySearchFields(self,RESPONSE=None):      def copySearchFields(self,RESPONSE=None):
         """copys import metadatafields to the object"""              """copys < metadatafields to the object"""
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
         for resource in resources:          for resource in resources:
   
Line 2164  class ECHO_collection(Folder, Persistent Line 1178  class ECHO_collection(Folder, Persistent
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     def reloadMetaDataFromStorageWarning(self,RESPONSE=None):  
         """warning"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/reloadMetaDataFromStorageWarning.zpt').__of__(self)  
             pt.content_type="text/html"  
             return pt()  
   
     def reloadMetaDataFromStorage(self,RESPONSE=None):  
         """copy metadata from the storage to ECHO"""  
   
         return reloadMetaDataFromStorage(self,RESPONSE=None)  
   
           
     def getPartnerCopyright(self,name,sonst="generic"):      def getPartnerCopyright(self,name,sonst="generic"):
Line 2195  class ECHO_collection(Folder, Persistent Line 1199  class ECHO_collection(Folder, Persistent
          retStr="<option>\n"           retStr="<option>\n"
                     
      try: # erste version copyrightTypes exists       try: # erste version copyrightTypes exists
          for partner in self.credits:                   for partner in self.getPartners():
              if selected and (partner==selected):                           partnerTitle = partner.title
                  retStr+="""<option selected value="%s">%s\n"""%(partner,partner)                           partnerId = partner.__name__
                            if selected and (partnerId==selected):
                                    retStr+="""<option selected value="%s">%s\n"""%(partnerId,partnerTitle)
              else:                               else:                
                  retStr+="""<option value="%s">%s\n"""%(partner,partner)                                   retStr+="""<option value="%s">%s\n"""%(partnerId,partnerTitle)
      except:       except:
          """nothing"""           """nothing"""
      return retStr       return retStr
     
     def getViewClassification(self):  #    def getViewClassification(self):
         if hasattr(self,'viewClassification'):  #        if hasattr(self,'viewClassification'):
             return self.viewClassification  #            return self.viewClassification
         else:  #        else:
             return ""  #            return ""
   
     def getTitle(self):  
     """title"""  
     try:  
         return self.title.encode('utf-8','ignore')   
     except:  
         self.title=self.title.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.title.encode('utf-8','ignore')   
       
     def getLabel(self):  
     """title"""  
     try:  
         return self.label.encode('utf-8','ignore')   
     except:  
         self.label=self.label.decode('iso-8859-1','ignore')[0:] #correnct conding error  
         return self.label.encode('utf-8','ignore')  
           
     def createRessourcesFromXMLForm(self):      def createRessourcesFromXMLForm(self):
         """form"""          """form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/createRessourcesFromXMLForm.zpt').__of__(self)              pt=zptFile(self, 'zpt/createRessourcesFromXMLForm.zpt')
         return pt()          return pt()
   
     def createRessourcesFromXML(self,fileupload):      def createRessourcesFromXML(self,fileupload):
Line 2238  class ECHO_collection(Folder, Persistent Line 1229  class ECHO_collection(Folder, Persistent
         for resource in dom.getElementsByTagName('resource'):          for resource in dom.getElementsByTagName('resource'):
             link=getText(resource.getElementsByTagName('link')[0].childNodes)              link=getText(resource.getElementsByTagName('link')[0].childNodes)
             label=getText(resource.getElementsByTagName('label')[0].childNodes)              label=getText(resource.getElementsByTagName('label')[0].childNodes)
                       pageimglink=getText(resource.getElementsByTagName('pageimglink')[0].childNodes)
             #splitted=link.split("?")[0].split("/")              #splitted=link.split("?")[0].split("/")
             #id=splitted[len(splitted)-1].encode('ascii')              #id=splitted[len(splitted)-1].encode('ascii')
             id=re.sub(" ","_",label).encode('ascii')              id=re.sub(" ","_",label).encode('ascii')
                           
             ret+="<p>"+label+"</p>"              ret+="<p>"+label+"</p>"
             manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","","",link.encode('ascii'),"","")                      manage_addECHO_resource(self,id,label.encode('ascii'),label.encode('ascii'),"","",pageimglink.encode('ascii'),link.encode('ascii'),"","")
         return ret          return ret
           
       security.declarePublic('getImageTag')
     def getImageTag(self):      def getImageTag(self):
         """GetTag"""          """GetTag"""
         try:          try:
Line 2253  class ECHO_collection(Folder, Persistent Line 1246  class ECHO_collection(Folder, Persistent
         except:          except:
             return ""              return ""
   
   
       def addMovie(self,id,title,label,description,contentType,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None):
           """SSS"""
   
           #manage_addECHO_movie(self,id,title,label,description,responsible,link,thumbUrl,rawFile,metalink,weight,credits=None,coords=None,RESPONSE=None)
           if not hasattr(self,id):
                   try:
                           manage_addECHO_movie(self,id,title,label,description,responsible,link,thumbUrl,rawFile,lowresFile,metalink,weight,credits=None,coords=None,RESPONSE=None)
                           return "done"
                   except:
                           return None
           else:
                   obj=getattr(self,id)
                   obj.changeECHO_movie_main(metalink,link,rawFile,lowresFile,thumbUrl,title,label,description,contentType,weight=weight)
   
           return "changed"
   
     def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):      def addResource(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
         """SSS"""          """SSS"""
         try:          try:
             manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)              manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None)
             return "done"              return "done"
         except:          except:
               logging.error("ECHOcollection: (AddResource): %s %s"%sys.exc_info()[0:2])
               return None
   
       def addResourceAndCreateLabelAndTitle(self,id,title,label,description,contentType,responsible,link,metalink,weight,credits=None,coords=None,RESPONSE=None):
           """SSS"""
           ret = self.addResource(id,title,label,description,contentType,responsible,link,metalink,weight,credits,coords,RESPONSE)
           if ret is None:
             return None              return None
   
           try:
               server2=getattr(self,id)
               server2.copyIndex_meta2echo_resource()
               server2.generate_label()
               server2.generate_title()
           except:
                 logging.error("An Error occured adding the resource A\n %s %s"%sys.exc_info()[0:2])
                 return None
           return "done"
     def getSecondaryLink(self):      def getSecondaryLink(self):
         """secondary link"""          """secondary link"""
         try:          try:
Line 2275  class ECHO_collection(Folder, Persistent Line 1301  class ECHO_collection(Folder, Persistent
         except:          except:
             return ""              return ""
                   
     def getCollectionTreeXML(self):      def getCollectionTreeXML(self,pwstr=None):
         """Tree as XML"""          """Tree as XML"""
   
         def getCollection(object,depth=0):          def addPassWd(str,pwstr=None):
                   """adds a user/passwd to an url"""
                   if pwstr:
                           txt2=re.sub(r"(http://)(.*?)","\g<1>%s@\g<2>"%pwstr,str)
                   else:
                           txt2=re.sub(r"(http://)(.*?)","\g<1>www:3333@\g<2>",str)
                   return txt2
   
           def getCollection(object,depth=0,pwstr=None):
             depth+=1              depth+=1
             collections=""              collections=""
             for entry in object.__dict__.keys():              for entry in object.__dict__.keys():
                 element=getattr(object,entry)                  element=getattr(object,entry)
                 try:                  try:
                     if element.meta_type in ["ECHO_collection","ECHO_group"]:                      if element.meta_type in ["ECHO_collection","ECHO_group"]:
                         collections+="<element name=\""+quote(element.title)+"\" url=\""+element.absolute_url()+"\">"                          collections+="<element name=\""+urllib.quote(element.title)+"\" url=\""+addPassWd(element.absolute_url(),pwstr=pwstr)+"\">"
                         collections+=getCollection(element,depth)+"</element>\n"                          collections+=getCollection(element,depth)+"</element>\n"
                 except:                  except:
                     """nothing"""                      """nothing"""
             return collections              return collections
                   
     ret="""<?xml version="1.0" encoding="utf-8" ?>"""      ret="""<?xml version="1.0" encoding="utf-8" ?>"""
         return ret+"<collection>"+getCollection(self)+"</collection>"          return ret+"<collection>"+getCollection(self,pwstr=pwstr)+"</collection>"
       
     def createJavaScript(self):  
         """OLD CreateJava"""  
         ret=javaScriptMain  
   
         dynamical="\n"  
         for ob in self.getGraphicCoords():  
         if ob[4][4] == "":    
             dynamical+="""Coords.push(new Coord('%s', Img, %s));\n"""%(ob[1],ob[0])  
         else:  
         dynamical+="""Coords.push(new Coord('%s', Img, %s));//%s\n"""%(ob[1],ob[0],ob[4][4])  
         dynamical+="ShowArrow(new getObj('i.%s'),Img,%s);\n"%(ob[1],ob[0])  
     ret+=javaHandler%dynamical  
         return ret  
   
     def createJSAreas(self):      def createAllJSAreas(self,mapColTypes=None):
         """create area calls for JavaScript"""          """create area calls for JavaScript"""
         dynamical="\n"          areas = self.getAllMapAreas(mapColTypes=mapColTypes)
         for ob in self.getGraphicCoords():          return self.createJSAreas(areas)
         if ob[5] == "area":  
             dynamical+="""addArea('%s', 'overview', %s, 'area');\n"""%(ob[1],ob[0])  
         else:  
             dynamical+="""addArea('%s', 'overview', %s, 'arrow');\n"""%(ob[1],ob[0])  
         return dynamical  
   
     def createMapHead(self):  
         """create javascript include and script tags for head"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_content_map_frag_js')).__of__(self)  
         return pt()  
   
     def createMapImg(self):  
     """generate img-tag for map"""  
     bt = BrowserCheck(self)  
     tag = ""  
     src = self.REQUEST['URL1'] + "/overview"  
     if bt.isN4:  
         tag += '<ilayer id="overview" visibility="show"><img src="%s"></ilayer>'%src  
     else:  
         tag += '<img id="overview" src="%s" />'%src  
     return tag  
           
     def createMapLink(self, ob, text=None):  
     """generate map link"""  
     bt = BrowserCheck(self)  
     id = ob[1]  
     link = ob[1]  
     if text == None:  
         text = ob[2]  
     tag = ""  
     if bt.isN4:  
         tag += '<ilayer id="a.%s"><a onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)  
         tag += ">" + text + "</a></ilayer>"  
     else:  
         tag = '<a id="a.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank"'%(id,id,id,link)  
         if ob[3].contentType == 'text-popup':  
         tag += ' title="%s"'%ob[3].description  
         tag += ">" + text + "</a>"  
     return tag  
   
     def createMapAux(self, ob, arrowsrc="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?dw=15&fn=icons/pfeil"):  
     """generate map link image, text and other stuff"""  
     id = ob[1]  
     link = ob[1]  
     vtype = ob[5]  
     ctype = ob[3].contentType  
     bt = BrowserCheck(self)  
     tag = ""  
   
     if bt.isN4:  
         tag += '<layer id="i.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)">'%(id,id,id)  
         if vtype == "view point":  
             rot = ob[4][4]  
         tag += '<a href="%s"><img border="0" src="%s&rot=%s" /></a>'%(link,arrowsrc,rot)  
         else:  
         tag += '<a href="%s"><img border="0" width="1000" height="1000" src="trans_img"'%(link)  
         if ctype == "text-popup":  
             desc = ob[3].description  
             tag += ' alt="%s"'%desc  
         tag += ' /></a>'  
         tag += '</layer>'  
     else:  
         tag = '<a id="b.%s" onmouseover="highlightPair(\'%s\', true)" onmouseout="highlightPair(\'%s\', false)" href="%s" target="_blank">'%(id,id,id,link)  
         if vtype == "view point":  
         rot = ob[4][4]  
         if bt.isIEWin and bt.versIE > 5:  
             tag += '<span id="i.%s" style="position:absolute; top:-100px; left:-100px; border-style:none; border-width=1px; filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src=\'%s&rot=%s\');"><img style="visibility:hidden" src="%s&rot=%s" /></span>'%(id,arrowsrc,rot,arrowsrc,rot)  
         else:  
             tag += '<img id="i.%s" src="%s&rot=%s" border="1" style="position:absolute; top:-100px; left:-100px; border-style:none;" />'%(id,arrowsrc,rot)  
         else:  
         if bt.isIEWin:  
             tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;background:url(area_img)"'%(id)  
         else:  
             tag += '<div id="i.%s" style="position:absolute; top:-100px; left:-100px;"'%(id)  
         if ctype == "text-popup":  
             desc = ob[3].description  
             tag += ' title="%s"'%desc  
         tag += '> </div>'  
         tag += '</a>'  
     return tag  
   
       emptyPartner=ECHO_partner("", "","", "", "", "", "", "", "")
           
     security.declarePublic('getCreditObject')      security.declarePublic('getCreditObject')
     def getCreditObject(self,name):      def getCreditObject(self,name):
Line 2400  class ECHO_collection(Folder, Persistent Line 1342  class ECHO_collection(Folder, Persistent
         try:          try:
             return getattr(self.partners,name)              return getattr(self.partners,name)
         except:          except:
             return ""              
               return self.emptyPartner
                   
   
     security.declarePublic('ECHO_generateNavBar')      security.declarePublic('ECHO_generateNavBar')
     def ECHO_generateNavBar(self):      def ECHO_generateNavBar(self):
Line 2421  class ECHO_collection(Folder, Persistent Line 1365  class ECHO_collection(Folder, Persistent
                     ret.append((label,link))                      ret.append((label,link))
         return ret          return ret
           
     security.declarePublic('ECHO_rerenderLinksMD')  
   
   
     def ECHO_rerenderLinksMDWarning(self):      def ECHO_rerenderLinksMDWarning(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/rerenderLinksWarning').__of__(self)                  pt=zptFile(self, 'zpt/rerenderLinksWarning')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
   
           
       security.declarePublic('ECHO_rerenderLinksMD')
     def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):      def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
         """Rerender all Links"""          """Rerender all Links"""
     return ECHO_rerenderLinksMD(self,obj,types)      return ECHO_rerenderLinksMD(self,obj,types)
   
           
     security.declarePublic('ECHO_newViewerLink')      def __init__(self,id,title,label,description="",contentType="",responsible="",credits="",weight="",sortfield="",coords=[],secondaryLinkTitle="",secondaryLink="",imageTag="",bgcolour="",isVisible=True):
       
   
     def getCoords(self):  
         try:  
               
             x=  [string.join(x,",") for x in self.coords]    
             return x  
   
         except:  
   
             return []  
           
     def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):  
   
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
Line 2469  class ECHO_collection(Folder, Persistent Line 1398  class ECHO_collection(Folder, Persistent
         self.secondaryLinkTitle=secondaryLinkTitle          self.secondaryLinkTitle=secondaryLinkTitle
         self.secondaryLink=secondaryLink          self.secondaryLink=secondaryLink
     self.bgcolour=bgcolour      self.bgcolour=bgcolour
           self.isVisible=isVisible
                   
   
     manage_options = Folder.manage_options+ Cacheable.manage_options+(      manage_options = Folder.manage_options+ Cacheable.manage_options+(
         {'label':'Main Config','action':'ECHO_collection_config'},          {'label':'Main Config','action':'ECHO_collection_config'},
         {'label':'Change Labels','action':'changeLabels'},          {'label':'Change Labels','action':'changeLabels'},
         {'label':'Change Titles','action':'changeTitles'},          {'label':'Change Titles','action':'changeTitles'},
           {'label':'Localize','action':'localizeObjects'},
     {'label':'Change Weights','action':'changeWeights'},      {'label':'Change Weights','action':'changeWeights'},
         {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},          {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},          {'label':'Export/Import Objects','action':'exportImportObjects_html'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
     {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},      {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
     {'label':'Set Startpage','action':'setStartpageFolderForm'},  
         {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},          {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},
     {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},          {'label':'ImportCollection','action':'importCollection'},
     {'label':'ImportCollection','action':'updateCollection'},          {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},
     {'label':'Copy MD for indexing and search','action':'copySearchFields'},  
         )          )
   
     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')  
   
           
     security.declarePublic('ECHO_collection_config')      security.declarePublic('ECHO_collection_config')
     def ECHO_collection_config(self):      def ECHO_collection_config(self):
Line 2525  class ECHO_collection(Folder, Persistent Line 1427  class ECHO_collection(Folder, Persistent
         if not hasattr(self,'sortfield'):          if not hasattr(self,'sortfield'):
             self.sortfield="weight"              self.sortfield="weight"
       
         if not hasattr(self,'coords'):          pt=zptFile(self, 'zpt/ChangeECHO_collection.zpt')
             self.coords=[]  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_collection.zpt').__of__(self)  
         return pt()          return pt()
   
   
     security.declarePublic('changeECHO_collection')  
   
   
     def getBgcolour(self):      def getBgcolour(self):
         """colour"""          """colour"""
         if hasattr(self,'bgcolour') and not (self.bgcolour==""):          if hasattr(self,'bgcolour') and not (self.bgcolour==""):
Line 2542  class ECHO_collection(Folder, Persistent Line 1438  class ECHO_collection(Folder, Persistent
         else:          else:
             return "#dddddd"              return "#dddddd"
                   
     def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",viewClassification=None,location=None,isAlwaysClickable=None):                  
       security.declarePublic('changeECHO_collection')         
       def changeECHO_collection(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",location=None,isAlwaysClickable=None,prefix="",suffix="",isVisible=True):
         """Aenderung der Properties"""          """Aenderung der Properties"""
   
         self.secondaryLink=secondaryLink          self.secondaryLink=secondaryLink
         self.secondaryLinkTitle=secondaryLinkTitle          self.secondaryLinkTitle=secondaryLinkTitle
         self.imageTag=imageTag          self.imageTag=imageTag
     self.bgcolour=bgcolour      self.bgcolour=bgcolour
         self.viewClassification=viewClassification  
         self.location=location          self.location=location
     self.isAlwaysClickable=isAlwaysClickable      self.isAlwaysClickable=isAlwaysClickable
           self.prefix=prefix[0:]
           self.suffix=suffix[0:]
           self.setIsVisible(isVisible)
           
         if coords:          setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
             coordsnew=[ string.split(x,",") for x in coords]  
             self.coords=coordsnew[0:]  
         else:  
             coordsnew=None  
             self.coords=None  
               
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)  
     try:  
         self.coords=coordsnew[0:] # HACK fehler in setECHO_collection  
         except:  
         """none"""  
                   
         self.sortfield=sortfield          self.sortfield=sortfield
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
       def setAlwaysClickable(self,flag="yes"):
               """set clickable"""
               if flag=="yes":
                       self.isAlwaysClickable="yes"
               else:
                       self.isAlwaysClickable=None
   
               return flag
   
     def showOverview(self):      def showOverview(self):
         """overview"""          """overview"""
         if 'ECHO_overview.html' in self.__dict__.keys():          if 'ECHO_overview.html' in self.__dict__.keys():
             return getattr(self,'ECHO_overview.html')()              return getattr(self,'ECHO_overview.html')()
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_content_overview.zpt').__of__(self)          pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')
         return pt()          return pt()
   
     security.declareProtected('View','index_html')  
           
       security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
         if self.ZCacheable_isCachingEnabled():          if self.ZCacheable_isCachingEnabled():
Line 2598  class ECHO_collection(Folder, Persistent Line 1495  class ECHO_collection(Folder, Persistent
         elif hasattr(self,'collection_index_template'):          elif hasattr(self,'collection_index_template'):
             ret=self.collection_index_template()                  ret=self.collection_index_template()    
         elif hasattr(self,'main_index_template'):          elif hasattr(self,'main_index_template'):
             ret=self.main_index_template()      
               ret=self.main_index_template.__of__(self)(self.main_template)
         else:          else:
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)              pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
         pt.content_type="text/html"          pt.content_type="text/html"
         ret=pt.render()          ret=pt.render()
   
     self.ZCacheable_set(ret)      self.ZCacheable_set(ret)
         return ret          return ret
   
     def content_html(self):      security.declarePublic('content_html')
       def content_html(self,**argv):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'collection')          #print "NN",argv
           ret = ECHO_basis.content_html(self,'collection')
           
           if type(ret) is StringType:
                  return ret.decode('utf-8')
           else:
                  return ret
           
           
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
Line 2635  class ECHO_collection(Folder, Persistent Line 1541  class ECHO_collection(Folder, Persistent
         return sendFile(self, 'js/hl_lib.js', 'text/plain')          return sendFile(self, 'js/hl_lib.js', 'text/plain')
   
     def js_lib_js(self):      def js_lib_js(self):
           """javascript -- old name"""
           return sendFile(self, 'js/baselib.js', 'text/plain')
   
       def baselib_js(self):
         """javascript"""          """javascript"""
         return sendFile(self, 'js/js_lib.js', 'text/plain')          return sendFile(self, 'js/baselib.js', 'text/plain')
   
     def getGraphicCoords(self):      def hl_add_js(self):
         """Give list of coordinates"""          """javascript"""
         subColTypes=['ECHO_collection','ECHO_resource']          return sendFile(self, 'js/hl_add.js', 'text/plain')
         ids=[]  
         for entrySearch in self.ZopeFind(self,obj_metatypes=subColTypes):  
             object=entrySearch[1]  
             if hasattr(object,'coords'):  
                 for coordtemp in object.coords:  
                     if len(coordtemp)>3:  
                         coord=coordtemp[0:4]  
                         label=""  
             vc=""  
                         if hasattr(object,'label') and not object.label=="":  
                             label=object.label  
                         elif hasattr(object,'title') and not object.title=="":  
                             label=object.title  
                         else:  
                             label=object.getId()  
             if object.viewClassification != "":  
                 vc=object.viewClassification  
             else:  
                 if len(coordtemp) > 4 and coordtemp[4] != "":  
                 vc="view point"  
                 else:  
                 vc="area"  
                         ids.append([string.join(coord,", "),object.getId(),label,object,coordtemp,vc])  
         return ids  
           
       def getAllMapAreas(self,mapColTypes=None):
           """Give list of coordinates"""
           if mapColTypes is None:
               mapColTypes=['ECHO_collection','ECHO_resource','ECHO_link','ECHO_externalLink']
   
           areas=[]
           for entry in self.getSubCols(subColTypes=mapColTypes):
               object=entry
               areas.extend(object.getMapAreas())
           return areas
       
   
       def deleteMapAreas(self):
           """deletes all map areas from this object"""
           for obs in self.ZopeFind(self, obj_metatypes=['MapArea'], search_sub=1):
               ob = obs[1]
               id = ob.id
               parent = ob.aq_parent
               print "deleting: ", ob.id
               parent._delObject(id)
           return "Done"
   
   
     getSubCols = ECHO_helpers.getSubCols      getSubCols = ECHO_helpers.getSubCols
   
       def getSubcolsXMLRpc(self,searchSimple):
           """simplesearch results suitable for xml rpc, gives back array objid,url"""
           
           return [x.absolute_url() for x in self.getSubCols(searchSimple=searchSimple)]
       
       
 Globals.InitializeClass(ECHO_collection)  Globals.InitializeClass(ECHO_collection)
           
 def manage_addECHO_collectionForm(self):  def manage_addECHO_collectionForm(self):
         """Add collection form"""          """Add collection form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_collectionForm.zpt').__of__(self)          pt=zptFile(self, 'zpt/AddECHO_collectionForm.zpt')
         return pt()          return pt()
   
   
 def manage_addECHO_collection(self,id,title,label,description,contentType,responsible,weight,sortfield,coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour=""):  def manage_addECHO_collection(self,id,title,label,description="",contentType="",responsible="",weight=0,sortfield="weight",coords="",secondaryLinkTitle="",secondaryLink="",credits=None,RESPONSE=None,imageTag="",bgcolour="",isVisible=True):
     """add a echo collection"""      """add a echo collection"""
           
   
     newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="")      newObj=ECHO_collection(id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle=secondaryLinkTitle,secondaryLink=secondaryLink,imageTag=imageTag,bgcolour="",isVisible=isVisible)
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
   
Line 2698  class ECHO_group(ECHO_collection): Line 1610  class ECHO_group(ECHO_collection):
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Main Config','action':'ECHO_group_config'},          {'label':'Main Config','action':'ECHO_group_config'},
         {'label':'Rerender Links','action':'ECHO_rerenderLinksMDWarning'},          {'label':'Rerender Links','action':'ECHO_rerenderLinksMDWarning'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},                  {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         )          )
           
     security.declareProtected('View','index_html')      security.declareProtected('View','index_html')
   
     def showRDF(self):  
         """showrdf"""  
             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
         ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""  
         ret+=self.getRDF(urn="echo:collectionroot")+"\n"  
   
         ret+="""</RDF:RDF>"""  
           
             return ret   
   
     def getRDF(self,urn=None):      def getRDF(self,urn=None):
         """rdf of the collection"""          """rdf of the collection"""
Line 2722  class ECHO_group(ECHO_collection): Line 1625  class ECHO_group(ECHO_collection):
                   
         if not urn:          if not urn:
             urn=self.absolute_url()              urn=self.absolute_url()
         li="""<RDF:li RDF:resource="%s" />\n"""              li="""<rdf:li rdf:resource="%s" />\n"""
                   
                   
         for content in contents:          for content in contents:
             ret+=content[1].getRDF()+"\n"                      ret+=self.unicodify(content[1].getRDF())+"\n"
                           
         ret+="""<RDF:Seq RDF:about="%s">\n"""%urn              ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
         for content in contents:          for content in contents:
             nurn=content[1].absolute_url()              nurn=content[1].absolute_url()
             ret+=li%nurn              ret+=li%nurn
         return ret+"</RDF:Seq>"              return ret+"</rdf:Seq>"
                   
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
Line 2752  class ECHO_group(ECHO_collection): Line 1655  class ECHO_group(ECHO_collection):
         elif hasattr(self,'main_index_template'):          elif hasattr(self,'main_index_template'):
             return self.main_index_template()                  return self.main_index_template()    
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)                  pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
Line 2768  class ECHO_group(ECHO_collection): Line 1671  class ECHO_group(ECHO_collection):
         if not hasattr(self,'coords'):          if not hasattr(self,'coords'):
             self.coords=[]              self.coords=[]
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_group.zpt').__of__(self)                  pt=zptFile(self, 'zpt/ChangeECHO_group.zpt')
         return pt()          return pt()
   
     def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):      def changeECHO_group(self,title,label,description,contentType,responsible,weight,secondaryLink,secondaryLinkTitle,credits=None,sortfield="weight",coords=None,RESPONSE=None,imageTag="",bgcolour="",logo=""):
         """Änderung der Properties"""                  """Aenderung der Properties"""
   
         self.secondaryLink=secondaryLink          self.secondaryLink=secondaryLink
         self.secondaryLinkTitle=secondaryLinkTitle          self.secondaryLinkTitle=secondaryLinkTitle
Line 2780  class ECHO_group(ECHO_collection): Line 1683  class ECHO_group(ECHO_collection):
         self.bgcolour=bgcolour          self.bgcolour=bgcolour
                 self.logo=logo                  self.logo=logo
                                   
         if coords:                  setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
             coordsnew=[ string.split(x,",") for x in coords]  
             self.coords=coordsnew[0:]  
         else:  
             coordsnew=None  
             self.coords=None  
   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)  
   
   
   
Line 2803  class ECHO_group(ECHO_collection): Line 1699  class ECHO_group(ECHO_collection):
                 except:                  except:
                     return "ECHO_groups"                      return "ECHO_groups"
   
           security.declarePublic('content_html')
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'group')                  return ECHO_basis.content_html(self,'group')
           
   
   
 def manage_addECHO_groupForm(self):  def manage_addECHO_groupForm(self):
         """Add group form"""          """Add group form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_groupForm.zpt').__of__(self)          pt=zptFile(self, 'zpt/AddECHO_groupForm.zpt')
         return pt()          return pt()
   
   
Line 2922  class ECHO_userFolder(UserFolder): Line 1819  class ECHO_userFolder(UserFolder):
             return 1              return 1
         return 0          return 0
   
 Globals.default__class_init__(ECHO_userFolder)  # ROC: problem with 2.12
   #Globals.default__class_init__(ECHO_userFolder)
   
   
   
Line 2983  class ECHO_root(Folder,Persistent,Implic Line 1881  class ECHO_root(Folder,Persistent,Implic
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
           
     meta_type="ECHO_root"      meta_type="ECHO_root"
       management_page_charset="utf-8"
       
       getSubCols = ECHO_helpers.getSubCols
   
       manage_options=Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_copyright_configForm'},
                   {'label':'Change Weights','action':'changeWeights'},
                   {'label':'Generate from RDF','action':'generateFromRDFForm'},
                   {'label':'update Resource Catalog','action':'updateResourceCatalog'},
                  )
   
   
   
   
       def getECHORootURL(self):
           return self.absolute_url()
   
     ###CDLI adds -> have to be removed      def getECHORoot(self):
           return self
       
   
      
       def mod_re_sub(self,pattern,replace,string):
           """re.sub aus mod re zur Verfuegung stellen"""
           return re.sub(pattern,replace,string)
       
       def findObjectFromFulltext(self,existUri):
           '''
           
           @param url:
           @param existUri:
           '''
   
           if existUri:
               #TODO: at the moment assume that the filename is unique, the whole has to changed to a system of ids.
               filename=existUri.split("/")[-1]
           
           founds=self.resourceCatalog.search({'fullTextUrl':os.path.splitext(filename)[0]})  
           
           ret=[(found.title,found.getObject().absolute_url(),found.getObject().aq_parent.absolute_url()) for found in founds]
           
           return ret
           
       def reindex(self,RESPONSE=None):
           """indiziere alle Objecte neu"""
           
           if RESPONSE:
               RESPONSE.write("<html><body>")
           
           resources=self.ZopeFind(self,obj_metatypes=["ECHO_resource"], search_sub=1)
           
           for resource in resources:
               resource[1].reindex()
               #print "<p> done %s </p>\n"
               if RESPONSE:
                   RESPONSE.write("<p> done %s </p>\n"%resource[0])
                   
           if RESPONSE:
               RESPONSE.write("<p> ok </p></html></body>\n")
               
   
       def setLanguage(self,lang):
               """Set language cookie"""
               self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
   
       def switchLanguage(self):
               """Set language cookie"""
               if self.getLanguage()=="en":
                       lang="de"
               else:
                       lang="en"
               
               self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1'])
               
       def getLanguage(self):
               """get language cookie"""
               lang= self.REQUEST.cookies.get('lang_exhibition','de')
               if lang == '':
                       lang="de"
               return lang
       
       def getContentOverviewTemplate(self):
           """produces overview template with macro"""
           pt = zptObjectOrFile(self, 'content_overview_template')
           return pt
   
       def mapstyle_css(self):
           """send mapstyle.css"""
           sendFile(self, 'html/ECHO_mapstyle.css', 'text/css')
   
   
       ###Cdli adds -> have to be removed
     def getTablet(self,item):      def getTablet(self,item):
         #print "getTablet"          #print "getTablet"
     try:      try:
Line 2997  class ECHO_root(Folder,Persistent,Implic Line 1986  class ECHO_root(Folder,Persistent,Implic
     ###END CDLI add      ###END CDLI add
   
           
       def URLquote(self, text):
           """urllib.quote fuer Michael"""
           return urllib.quote(text)
   
   
       def checkResource(self,id):
               """checks if a resource is in the tree, gives back none or list of resources"""
               if not id:
                   id=""
               splitted=id.split("/")
               id=splitted[len(splitted)-1]
               if hasattr(self,"_v_checkResource") and self._v_checkResource.has_key(id): #existiert ein cache und id ist bereits drin?
                               return self._v_checkResource[id]
   
               else:
                       resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],obj_ids=[id],search_sub=1)
   
                       if not hasattr(self,"_v_checkResource"): self._v_checkResource={}#lege cache an falls nicht existent
                       if resources:
                               self._v_checkResource[id]=resources[0:] # slicing to be sure that data is stabil
                       else:
                               self._v_checkResource[id]=None
                       
                       return self._v_checkResource[id]
               
       def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):
               """sendform"""
               toaddrs=["dwinter@mpiwg-berlin.mpg.de"]
               
               msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n"
                      % (fromaddr, ", ".join(toaddrs),"testsub"))
               server = smtplib.SMTP(server)
               #server.set_debuglevel(1)
               msg=msg+content
               server.sendmail(fromaddr, toaddrs, msg)
               server.quit()
                    
     def generateFromRDFForm(self):      def generateFromRDFForm(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/generateFromRDFForm').__of__(self)                  pt=zptFile(self, 'zpt/generateFromRDFForm')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
Line 3036  class ECHO_root(Folder,Persistent,Implic Line 2062  class ECHO_root(Folder,Persistent,Implic
             global key              global key
             global value              global value
             seq=""              seq=""
             if name=="RDF:Seq":                      if name=="rdf:Seq":
                 key=attrs.get('RDF:about')                              key=attrs.get('rdf:about')
                 try: # teste ob liste                  try: # teste ob liste
                     x=seqs[key][0]                      x=seqs[key][0]
                 except:                  except:
Line 3045  class ECHO_root(Folder,Persistent,Implic Line 2071  class ECHO_root(Folder,Persistent,Implic
                     seqs[key]=[]                      seqs[key]=[]
   
                           
             elif name=="RDF:Description":                      elif name=="rdf:Description":
                 key=attrs.get('RDF:about')                              key=attrs.get('rdf:about')
                                   
   
             elif name=="RDF:li":                      elif name=="rdf:li":
                 name=attrs.get('RDF:resource')                              name=attrs.get('rdf:resource')
                 seqs[key].append(name)                  seqs[key].append(name)
   
             elif name=="ECHONAVIGATION:type":                      elif name=="echonavigation:type":
                 value="type"                  value="type"
   
             elif name=="ECHONAVIGATION:name":                      elif name=="echonavigation:name":
                 value="name"                  value="name"
             elif name=="ECHONAVIGATION:linkClickable":                      elif name=="echonavigation:linkClickable":
                 value="linkClickable"                  value="linkClickable"
                                   
         def end_element(name):          def end_element(name):
Line 3111  class ECHO_root(Folder,Persistent,Implic Line 2137  class ECHO_root(Folder,Persistent,Implic
                 ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"                  ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                             resource[1].weight=argv[resource[1].getId()][0:]                              resource[1].weight=argv[resource[1].getId()][0:]
             except:              except:
                 """not"""                              pass
         return ret          return ret
   
     def changeWeights(self):      def changeWeights(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeWeightForm').__of__(self)                  pt=zptFile(self, 'zpt/changeWeightForm')
         pt.content_type="text/html"  
         return pt()  
     getSubCols = ECHO_helpers.getSubCols  
   
     manage_options=Folder.manage_options+(  
         {'label':'Main Config','action':'ECHO_copyright_configForm'},  
         {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},  
         {'label':'Change Weights','action':'changeWeights'},  
         {'label':'Generate from RDF','action':'generateFromRDFForm'},  
   
 )  
   
       
     def showRDF(self):  
         """showrdf"""  
             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
         ret="""<?xml version="1.0" encoding="utf-8"?>\n<RDF:RDF xmlns:RDF="http://www.w3.org/1999/02/22-rdf-syntax-ns#"  xmlns:ECHONAVIGATION="http://www.echo.eu/rdf#">\n"""  
         ret+=self.getRDF(urn="echo:collectionroot")+"\n"  
   
         ret+="""</RDF:RDF>"""  
             return ret  
   
   
     def reloadMetaDataFromStorageWarning(self,RESPONSE=None):  
         """warning"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/reloadMetaDataFromStorageWarning.zpt').__of__(self)  
             pt.content_type="text/html"              pt.content_type="text/html"
             return pt()              return pt()
   
     def reloadMetaDataFromStorage(self,RESPONSE=None):  
         """reload MD from Storage"""  
   
         return reloadMetaDataFromStorage(self,RESPONSE)  
           
     def getRDF(self,urn=None):      def getRDF(self,urn=None):
         """rdf of the collection"""          """rdf of the collection"""
Line 3158  class ECHO_root(Folder,Persistent,Implic Line 2154  class ECHO_root(Folder,Persistent,Implic
   
         ret=getRDFDescription(self,self.absolute_url(),urn=urn)          ret=getRDFDescription(self,self.absolute_url(),urn=urn)
                   
         li="""<RDF:li RDF:resource="%s" />\n"""              li="""<rdf:li rdf:resource="%s" />\n"""
   
                   
         for content in contents:          for content in contents:
             ret+=content[1].getRDF()+"\n"              ret+=content[1].getRDF()+"\n"
                           
         ret+="""<RDF:Seq RDF:about="%s">\n"""%urn              ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
         for content in contents:          for content in contents:
             nurn=content[1].absolute_url()              nurn=content[1].absolute_url()
             ret+=li%nurn              ret+=li%nurn
         return ret+"</RDF:Seq>"              return ret+"</rdf:Seq>"
                   
   
     def showContent(self,path):      def showContent(self,path):
Line 3183  class ECHO_root(Folder,Persistent,Implic Line 2179  class ECHO_root(Folder,Persistent,Implic
           
   
     def getBibTag(self,tag,content):      def getBibTag(self,tag,content):
         """get field tag fĂźr index-meta-generation"""              """get field tag for index-meta-generation"""
         if not content or content=="":          if not content or content=="":
             return ""              return ""
         ret="<%s>"%tag          ret="<%s>"%tag
Line 3194  class ECHO_root(Folder,Persistent,Implic Line 2190  class ECHO_root(Folder,Persistent,Implic
         return ret          return ret
   
     def getValueFromClass(self,field,found):      def getValueFromClass(self,field,found):
         """retattribute falss existing"""              """ret attribute if existing"""
         try:          try:
                           
             return getattr(found,field).decode('ascii','ignore')  
                       return getattr(found,field)#.decode('ascii','ignore')
   
   
   
         except:          except:
                       logging.error("can't: decode: %s"%repr(field))
                       logging.error("      %s %s"%(sys.exc_info()[0],sys.exc_info()[1]))
             return ""              return ""
           
       security.declarePublic('getImageTag')
     def getImageTag(self):      def getImageTag(self):
         """needed by main_template"""          """needed by main_template"""
         return ""          return ""
           
     secondaryLink="" #needed by main_template      secondaryLink="" #needed by main_template
     secondaryLinkTitle="" #needed by main_template      secondaryLinkTitle="" #needed by main_template
           
Line 3211  class ECHO_root(Folder,Persistent,Implic Line 2215  class ECHO_root(Folder,Persistent,Implic
     """hack"""      """hack"""
     return "#dddddd"      return "#dddddd"
   
       security.declareProtected('View','contentTypeSelector_HTML')
     def contentTypeSelector_HTML(self,selected=None):      def contentTypeSelector_HTML(self,selected=None):
         """give type selector"""          """give type selector"""
         if not selected:          if not selected:
Line 3253  class ECHO_root(Folder,Persistent,Implic Line 2258  class ECHO_root(Folder,Persistent,Implic
          """nothing"""           """nothing"""
      return retStr       return retStr
   
     def renderingTypeSelector_HTML(self,selected=None):  
          """give type selector"""  
      if not selected:  
          retStr="<option selected>\n"  
      else:  
          retStr="<option>\n"  
            
      try: # erste version renderingTypes exists  
          for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):  
              if selected and (renderingType[0]==selected):  
                  retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])  
              else:                  
                  retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])  
      except:  
          """nothing"""  
      return retStr  
   
   
     def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):      def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):
          """give type selector"""           """give type selector"""
Line 3321  class ECHO_root(Folder,Persistent,Implic Line 2309  class ECHO_root(Folder,Persistent,Implic
          """nothing"""           """nothing"""
      return retStr       return retStr
     
     mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version Ăźber echoroot??      mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version ueber echoroot??
   
     def mediaTypeSelector_HTML(self,selected=None):      def mediaTypeSelector_HTML(self,selected=None):
          """give type selector"""           """give type selector"""
Line 3361  class ECHO_root(Folder,Persistent,Implic Line 2349  class ECHO_root(Folder,Persistent,Implic
         return "changed all contenttypes in: "+self.title          return "changed all contenttypes in: "+self.title
   
   
       def repairAllCoords(self):
           """updates map coordinates on the same and sublevels"""
           return repairCoords(self)
   
   
     def patchViewClassification(self,obj=None):      def patchViewClassification(self,obj=None):
         """setze viewClassification heuristisch"""          """setze viewClassification heuristisch"""
   
Line 3395  class ECHO_root(Folder,Persistent,Implic Line 2388  class ECHO_root(Folder,Persistent,Implic
   
     def deleteCache(self,obj=None,RESPONSE=None):      def deleteCache(self,obj=None,RESPONSE=None):
         """setze alle collections auf cache = CacheManager"""          """setze alle collections auf cache = CacheManager"""
   
       
         if not obj:          if not obj:
             obj = self              obj = self
               
         entries=obj.ZopeFind(obj,search_sub=1)          entries=obj.ZopeFind(obj,search_sub=1)
   
         for entry in entries:          for entry in entries:
         if hasattr(entry[1],'_v_hash'):          if hasattr(entry[1],'_v_hash'):
             entry[1]._v_hash=None              entry[1]._v_hash=None
                           
   
   
           
         return "changed all CM in: "+self.title          return "changed all CM in: "+self.title
   
   
           security.declarePublic('ECHO_newViewerLink')
     def ECHO_newViewerLink(self,obj=None):      def ECHO_newViewerLink(self,obj=None):
         """change links (:86 faellt weg)"""          """change links (:86 faellt weg)"""
   
Line 3451  class ECHO_root(Folder,Persistent,Implic Line 2437  class ECHO_root(Folder,Persistent,Implic
   
     def formatAscii(self,str,url=None):      def formatAscii(self,str,url=None):
         """ersetze ascii umbrueche durch <br>"""          """ersetze ascii umbrueche durch <br>"""
         #url=None  
       if not str: 
               return ""
   
         if url:          if url:
                           
             retStr=""              retStr=""
Line 3463  class ECHO_root(Folder,Persistent,Implic Line 2452  class ECHO_root(Folder,Persistent,Implic
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)                  retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
             str=retStr              str=retStr
         if str:          if str:
             return re.sub(r"[\n]","<br/>",str)              str = re.sub(r"[\n]","<br/>",str)
         else:              return unicodify(str)
             return ""  
           
     def link2html(self,str):  
         """link2html fuer VLP muss hier noch raus"""  
         if str:  
   
             str=re.sub("\&","&amp;",str)  
             dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>")  
             links=dom.getElementsByTagName("link")  
               
   
             for link in links:  
                 link.tagName="a"  
         ref=link.getAttribute("ref")  
         pn=link.getAttribute("page")  
               
                 if self.checkRef(ref):  
             if pn:  
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)  
             else:              else:
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)              return u""
   
   
             newxml=dom.toxml('utf-8')  
         
         retStr=regexpTXT.search(newxml)  
   
         return retStr.group(1)  
   
                  
         return ""  
   
     def xml2html(self,str,quote="yes"):  
         """link2html fuer VLP muss hier noch raus"""  
     #print str  
   
         if str:  
             if quote=="yes2":  
                 str=re.sub("\&","&amp;",str)  
             dom=xml.dom.minidom.parseString(str)  
             links=dom.getElementsByTagName("link")  
               
             for link in links:  
                 link.tagName="a"  
                 ref=link.getAttribute("ref")  
         pn=link.getAttribute("page")  
   
                 if self.checkRef(ref):  
             if pn:  
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)  
             else:  
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)  
   
             str= dom.toxml()  
                   
         #print link.toxml('utf-8')      link2html=vlp_xmlhelpers.link2html
         retStr=regexpPage.search(str)      related2html=vlp_xmlhelpers.related2html
   
         return retStr.group(1)      xml2html=vlp_xmlhelpers.xml2html
         return ""   
       checkRef=vlp_xmlhelpers.checkRef
     def checkRef(self,ref):      
         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':'','vl_sites':''}  #    def checkRef(self,ref):
         res=None  #            if ref[0:3]=='lit':
         for db in dbs.keys():  #                    if len(self.library_data({ 'id':ref}))>0:
   #                            return 1
             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))  #            try:
         return res  #                    if ref[0:7]=="tec_cat":
                                       #                            return 1
     #Ende Methode fuer vlp  #            except:
   #                    """nothing"""
   #                    
   #            dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''}
   #            res=None
   #            for db in dbs.keys():
   #                    res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
   #            return res
   #                                    
   #    #Ende Methode fuer vlp
   
     def PgQuoteString(self,string):      def PgQuoteString(self,string):
         """Quote string"""          """Quote string"""
   
         return libpq.PgQuoteString(string)          return libpq.PgQuoteString(string)
                   
       security.declareProtected('View','getPartners')
     def getPartners(self):      def getPartners(self):
         """Get list of Partners. Presently only from a subfolder partners"""          """Get list of Partners. Presently only from a subfolder partners"""
                               if hasattr(self,'partners'):            
         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]                  ret = [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
                     def sort_title(one, another) : return cmp(one.title, another.title)
                   ret.sort(sort_title)
                   return ret
           else:
                   return []
       
     def getInstitutions(self):      def getInstitutions(self):
         """Get list of Partners. Presently only from a subfolder partners"""          """Get list of Partners. Presently only from a subfolder partners"""
Line 3560  class ECHO_root(Folder,Persistent,Implic Line 2511  class ECHO_root(Folder,Persistent,Implic
     <partners>"""      <partners>"""
                   
     for partner in partners:      for partner in partners:
             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),unicode(partner.title,'utf-8','replace'))              ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)
   
         return ret+"\n</partners>"          return ret+"\n</partners>"
           
Line 3598  class ECHO_root(Folder,Persistent,Implic Line 2549  class ECHO_root(Folder,Persistent,Implic
                   
         ret="""<html><body><h2>Resources in ECHO</h3>"""          ret="""<html><body><h2>Resources in ECHO</h3>"""
                   
         resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)              resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource','VLP_resource'],search_sub=1)
         ret+="""<h3>Found %i resources</h3>"""%len(resources)          ret+="""<h3>Found %i resources</h3>"""%len(resources)
         resources.sort(sortHTML)          resources.sort(sortHTML)
         for resource in resources:          for resource in resources:
Line 3624  class ECHO_root(Folder,Persistent,Implic Line 2575  class ECHO_root(Folder,Persistent,Implic
         """gebe all ressourcen aus"""          """gebe all ressourcen aus"""
         ret="""<?xml version="1.0" ?>          ret="""<?xml version="1.0" ?>
                  <index>"""                   <index>"""
         for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):              for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource','VLP_resource'],search_sub=1):
   
             echo_url=resource[1].absolute_url()              echo_url=resource[1].absolute_url()
             if hasattr(resource[1],'link'):              if hasattr(resource[1],'link'):
Line 3641  class ECHO_root(Folder,Persistent,Implic Line 2592  class ECHO_root(Folder,Persistent,Implic
         self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")          self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
         self.REQUEST.RESPONSE.write(ret)          self.REQUEST.RESPONSE.write(ret)
   
       def getCollectionsXML(self,viewerType=None,filter=None):
               """gebe collections aus"""
               ret="""<?xml version="1.0" ?>
                        <index>"""
               for resource in self.ZopeFind(self,obj_metatypes=['ECHO_collection','ECHO_group'],search_sub=1):
   
                       echo_url=resource[1].absolute_url()
                    
                       ret+="""\n<collection echoLink="%s"/>"""%urllib.quote(echo_url,safe='/:?')
               ret +="""\n</index>"""
               
               self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
               self.REQUEST.RESPONSE.write(ret)
   
     def getFullTextsXML(self,viewerType=None,filter=None):      def getFullTextsXML(self,viewerType=None,filter=None):
         """gebe all ressourcen aus"""          """gebe all ressourcen aus"""
         ret="""<?xml version="1.0" ?>          ret="""<?xml version="1.0" ?>
Line 3667  class ECHO_root(Folder,Persistent,Implic Line 2632  class ECHO_root(Folder,Persistent,Implic
   
     def getMetaDatasXML(self,viewerType=None,filter=None):      def getMetaDatasXML(self,viewerType=None,filter=None):
         """gebe all ressourcen aus"""          """gebe all ressourcen aus"""
               # check if the request's host part was OK
               http_host = self.REQUEST['HTTP_HOST']
               host_port = self.REQUEST['SERVER_PORT']
               fix_host = None
               if http_host and http_host.rfind(host_port) == -1:
                       print "HTTP_HOST needs fixing!"
                       fix_host = http_host + ":" + host_port
   
         ret="""<?xml version="1.0" ?>          ret="""<?xml version="1.0" ?>
                  <index>"""                   <index>"""
         for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):          for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
   
             echo_url=resource[1].absolute_url()              echo_url=resource[1].absolute_url()
                       if fix_host:
                               #print "replacing ", http_host, " by ", fix_host
                               echo_url = string.replace(echo_url, http_host, fix_host, 1)
                           
             if hasattr(resource[1],'link'):              if hasattr(resource[1],'link'):
                 meta_url=echo_url+"/getMetaDataXML"                  meta_url=echo_url+"/getMetaDataXML"
Line 3690  class ECHO_root(Folder,Persistent,Implic Line 2666  class ECHO_root(Folder,Persistent,Implic
                                   
         ret +="""\n</index>"""          ret +="""\n</index>"""
                   
           
         self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")          self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
         self.REQUEST.RESPONSE.write(ret)          self.REQUEST.RESPONSE.write(ret)
   
Line 3716  class ECHO_root(Folder,Persistent,Implic Line 2691  class ECHO_root(Folder,Persistent,Implic
         inst=self.ZopeFind(self.institutions, obj_ids=[id])          inst=self.ZopeFind(self.institutions, obj_ids=[id])
         return inst          return inst
   
       def updateResourceCatalog(self,REQUEST,RESPONSE):
           """update ressource catalog"""
           catalog=getattr(self,'resourceCatalog',None)
           if not catalog:
               return """<html><body><h3>No resourceCatalog available</h3></body></html>"""
           
           else:
               class element:
                   def __init__(self,group,name):
                       self.group=group
                       self.name=name
               catalog.manage_delObjects('author splitter')
               #elements=[element('Stop Words',""" Don't remove stop words' """),element('Word Splitter','ECHO author splitter')]
               elements=[element('Word Splitter','ECHO author splitter')]
               manage_addLexicon(catalog,id="author splitter",elements=elements)
               
               return catalog.manage_catalogReindex(REQUEST,RESPONSE,'manage_main')
               
           
       def checkMetaDataLinks(self,correct=None):
           """check all metadatalinks and if correct is set change the servername to content.mpiwg-berlin.mpg.de"""
           
           self.REQUEST.RESPONSE.write("<html><body>")
           for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
               metalink=resource[1].metalink
           
               try:
                   url=urllib.urlopen(metalink)
               except:
                   
                   self.REQUEST.RESPONSE.write("<p>ERROR (opening %s):"%resource[1].absolute_url() +" -- %s %s <br>"%sys.exc_info()[0:2])
                   self.REQUEST.RESPONSE.write("-----------%s"%metalink)
               
                   if correct:
                       urlparsed=[x for x in urlparse.urlparse(metalink)]
                       urlparsed[1]="content.mpiwg-berlin.mpg.de"
                       neu=urlparse.urlunparse(urlparsed)
                       resource[1].metalink=neu[0:]
                       self.REQUEST.RESPONSE.write("----------changed to:%s)"%neu)
                   
 def manage_addECHO_root(self,id,title,RESPONSE=None):  def manage_addECHO_root(self,id,title,RESPONSE=None):
     """Add an ECHO_root"""      """Add an ECHO_root"""
Line 3726  def manage_addECHO_root(self,id,title,RE Line 2740  def manage_addECHO_root(self,id,title,RE
   
 def manage_addECHO_rootForm(self):  def manage_addECHO_rootForm(self):
         """Nothing yet"""          """Nothing yet"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_root.zpt').__of__(self)          pt=zptFile(self, 'zpt/AddECHO_root.zpt')
         return pt()          return pt()
   
 class ECHO_copyrightType(Folder):  class ECHO_copyrightType(Folder,ECHO_basis):
     """copyright typ"""      """copyright typ"""
   
     meta_type="ECHO_copyrightType"      meta_type="ECHO_copyrightType"
Line 3747  class ECHO_copyrightType(Folder): Line 2761  class ECHO_copyrightType(Folder):
   
     def ECHO_copyrightType_config_mainForm(self):      def ECHO_copyrightType_config_mainForm(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_copyrightType').__of__(self)                  pt=zptFile(self, 'zpt/ChangeECHO_copyrightType')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
Line 3762  class ECHO_copyrightType(Folder): Line 2776  class ECHO_copyrightType(Folder):
   
 def manage_addECHO_copyrightTypeForm(self):  def manage_addECHO_copyrightTypeForm(self):
         """Form for adding a ressource"""          """Form for adding a ressource"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_copyrightTypeForm.zpt').__of__(self)          pt=zptFile(self, 'zpt/AddECHO_copyrightTypeForm.zpt')
         return pt()          return pt()
   
   
Line 3778  def manage_addECHO_copyrightType(self,id Line 2792  def manage_addECHO_copyrightType(self,id
     
   
     
 class ECHO_partner(Image,Persistent):  
     """ECHO Partner"""  
   
     meta_type="ECHO_partner"  
   
     def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):  
         self.__name__=id  
         self.title=title  
         self.url=url  
         self.person=person  
         self.email=email  
         self.country=country  
         self.color=color  
         self.precondition=precondition  
         self.copyrightType=copyrightType  
         data, size = self._read_data(file)  
         content_type=self._get_content_type(file, data, id, content_type)  
         self.update_data(data, content_type, size)  
   
     manage_options = Image.manage_options+(  
         {'label':'Partner Information','action':'ECHO_partner_config'},  
         )  
   
           
     def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):  class ECHO_linkList(ZopePageTemplate,ECHO_basis):
         """Change main information"""  
         self.url=url  
         self.person=person  
         self.email=email  
         self.country=country  
         self.color=color  
         self.copyrightType=copyrightType  
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
               
               
   
     def ECHO_partner_config(self):  
         """Main configuration"""  
         if not hasattr(self,'url'):  
             self.url=""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_partner.zpt').__of__(self)  
         return pt()  
   
           
 manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),  
                              Kind='ECHO_partner',kind='ECHO_partner')  
   
   
   
 def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',  
                     REQUEST=None):  
     """  
     Add a new ECHO_partner object.  
   
     Creates a new ECHO_partner object 'id' with the contents of 'file'.  
     Based on Image.manage_addImage  
     """  
   
     id=str(id)  
     title=str(title)  
     content_type=str(content_type)  
     precondition=str(precondition)  
   
     id, title = OFS.Image.cookId(id, title, file)  
   
     self=self.this()  
   
     # First, we create the image without data:  
     self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))  
   
     # Now we "upload" the data.  By doing this in two steps, we  
     # can use a database trick to make the upload more efficient.  
     if file:  
         self._getOb(id).manage_upload(file)  
     if content_type:  
         self._getOb(id).content_type=content_type  
   
     if REQUEST is not None:  
         try:    url=self.DestinationURL()  
         except: url=REQUEST['URL1']  
         REQUEST.RESPONSE.redirect('%s/manage_main' % url)  
     return id  
   
 class ECHO_linkList(ZopePageTemplate):  
     """LinkList Objekt"""      """LinkList Objekt"""
     meta_type="ECHO_linkList"      meta_type="ECHO_linkList"
   
Line 3874  class ECHO_linkList(ZopePageTemplate): Line 2805  class ECHO_linkList(ZopePageTemplate):
   
     def content_html(self):      def content_html(self):
     """content_html"""      """content_html"""
     return content_html(self,'pageTemplate')          return ECHO_basis.content_html(self,'pageTemplate')
   
     def changeECHO_linkListWeightForm(self):      def changeECHO_linkListWeightForm(self):
         """change"""          """change"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_linkListTemplate.zpt').__of__(self)          pt=zptFile(self, 'zpt/ChangeECHO_linkListTemplate.zpt')
         return pt()          return pt()
   
     def changeECHO_linkListWeight(self,contentType,label,RESPONSE=None):      def changeECHO_linkListWeight(self,contentType,label,RESPONSE=None):
Line 3898  class ECHO_linkList(ZopePageTemplate): Line 2829  class ECHO_linkList(ZopePageTemplate):
     def getcontentType(self):      def getcontentType(self):
         """get contentType"""          """get contentType"""
         if hasattr(self,'contentType'):          if hasattr(self,'contentType'):
             return self.contentType              return normalizeCt(self.contentType)
         else:          else:
             return 0              return 0
   
Line 3909  class ECHO_linkList(ZopePageTemplate): Line 2840  class ECHO_linkList(ZopePageTemplate):
          self.ZBindings_edit(self._default_bindings)           self.ZBindings_edit(self._default_bindings)
          if text is None:           if text is None:
              text = ''               text = ''
            if content_type is None:
                content_type = self.content_type
          self.pt_edit(text, contentType)           self.pt_edit(text, contentType)
   
   
Line 3916  class ECHO_linkList(ZopePageTemplate): Line 2849  class ECHO_linkList(ZopePageTemplate):
   
 def manage_addECHO_linkListForm(self):  def manage_addECHO_linkListForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkListTemplate.zpt').__of__(self)      pt=zptFile(self, 'zpt/AddECHO_linkListTemplate.zpt')
     return pt()      return pt()
   
 from urllib import quote  
   
   
 def manage_addECHO_linkList(self, id, label,contentType=0,title=None, text=None,  def manage_addECHO_linkList(self, id, label,contentType=0,title=None, text=None,
                            REQUEST=None, submit=None):                             REQUEST=None, submit=None):
Line 3953  def manage_addECHO_linkList(self, id, la Line 2884  def manage_addECHO_linkList(self, id, la
             u = REQUEST['URL1']              u = REQUEST['URL1']
   
         if submit == " Add and Edit ":          if submit == " Add and Edit ":
             u = "%s/%s" % (u, quote(id))              u = "%s/%s" % (u, urllib.quote(id))
         REQUEST.RESPONSE.redirect(u+'/manage_main')          REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''      return ''
           
   
 class ECHO_support(Folder):  class ECHO_support(Folder,ECHO_basis):
     """gefšrdert durch"""          """gefoerdert durch"""
     meta_type="ECHO_support"      meta_type="ECHO_support"
           
           
Line 3983  class ECHO_support(Folder): Line 2914  class ECHO_support(Folder):
   
     def ECHO_support_configForm(self):      def ECHO_support_configForm(self):
         """change form"""          """change form"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_support').__of__(self)                  pt=zptFile(self, 'zpt/ChangeECHO_support')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
Line 3997  class ECHO_support(Folder): Line 2928  class ECHO_support(Folder):
                   
 def manage_addECHO_supportForm(self):  def manage_addECHO_supportForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_support.zpt').__of__(self)      pt=zptFile(self, 'zpt/AddECHO_support.zpt')
     return pt()      return pt()
   
 def manage_addECHO_support(self, id,institutions=None,RESPONSE=None):  def manage_addECHO_support(self, id,institutions=None,RESPONSE=None):
Line 4011  def manage_addECHO_support(self, id,inst Line 2942  def manage_addECHO_support(self, id,inst
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                   
   # ECHO - owner of original
   class ECHO_ownerOriginal(Folder,ECHO_basis):
           """besitzer des originals"""
           meta_type="ECHO_ownerOriginal"
           security=ClassSecurityInfo()
           
           
           def __init__(self,id,institutions=None):
                   """init"""
                   self.id=id
                   self.title=''
                   self.institutions=toList(institutions)
   
           security.declarePublic('getOwner')
           def getOwner(self):
                   """return institutions"""
                   if self.institutions:
                           return self.institutions
                   else:
                           return []
                   
           manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_ownerOriginal_configForm'},
                   )
   
           def ECHO_ownerOriginal_configForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_ownerOriginal')
                   pt.content_type="text/html"
                   return pt()
   
           def ECHO_ownerOriginal_config(self,institutions=None,RESPONSE=None):
                   """change"""
                   self.institutions=toList(institutions)
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
   
 class ECHO_institution(Image,Persistent):  def manage_addECHO_ownerOriginalForm(self):
       """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_ownerOriginal.zpt')
       return pt()
   
   def manage_addECHO_ownerOriginal(self, id,institutions=None,RESPONSE=None):
           """add the copyright"""
   
           meta_type="ECHO_ownerOriginal"
           
           
           self._setObject(id, ECHO_ownerOriginal(id,institutions))
   
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
                   
   # --------------------------------------------------------------------------------             
   
   # ECHO - digitized copy by
   class ECHO_digiCopyBy(Folder,ECHO_basis):
           """besitzer des originals"""
           meta_type="ECHO_digiCopyBy"
           security=ClassSecurityInfo()
           
           
           def __init__(self,id,institutions=None):
                   """init"""
                   self.id=id
                   self.title=''
                   self.institutions=toList(institutions)
   
           security.declarePublic('getDigiCopyBy')
           def getDigiCopyBy(self):
                   """return institutions"""
                   if self.institutions:
                           return self.institutions
                   else:
                           return []
                   
           manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_digiCopyBy_configForm'},
                   )
   
           def ECHO_digiCopyBy_configForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_digiCopyBy')
                   pt.content_type="text/html"
                   return pt()
   
           def ECHO_digiCopyBy_config(self,institutions=None,RESPONSE=None):
                   """change"""
                   self.institutions=toList(institutions)
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
                   
   def manage_addECHO_digiCopyByForm(self):
       """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_digiCopyBy.zpt')
       return pt()
   
   def manage_addECHO_digiCopyBy(self, id,institutions=None,RESPONSE=None):
           """add the copyright"""
   
           meta_type="ECHO_digiCopyBy"
           
           
           self._setObject(id, ECHO_digiCopyBy(id,institutions))
   
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
                   
   # --------------------------------------------------------------------------------  
   
   class ECHO_institution(Image,Persistent,ECHO_basis):
     """ECHO Institution"""      """ECHO Institution"""
   
     meta_type="ECHO_institution"      meta_type="ECHO_institution"
Line 4049  class ECHO_institution(Image,Persistent) Line 3093  class ECHO_institution(Image,Persistent)
         """Main configuration"""          """Main configuration"""
         if not hasattr(self,'url'):          if not hasattr(self,'url'):
             self.url=""              self.url=""
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_institution.zpt').__of__(self)          pt=zptFile(self, 'zpt/ChangeECHO_institution.zpt')
         return pt()          return pt()
   
                   
Line 4091  def manage_addECHO_institution(self, id, Line 3135  def manage_addECHO_institution(self, id,
         except: url=REQUEST['URL1']          except: url=REQUEST['URL1']
         REQUEST.RESPONSE.redirect('%s/manage_main' % url)          REQUEST.RESPONSE.redirect('%s/manage_main' % url)
     return id      return id
   
   def repairCoords(self):
           """updates map coordinates to new MapArea objects"""
           msg = ""
           for cols in self.ZopeFind(self, obj_metatypes=['ECHO_collection','ECHO_resource'], search_sub=1):
               col = cols[1]
               if not hasattr(col, 'coords'):
                   continue
               print "fixing: ", col.id
               msg += "fixing: "+col.id+"\n"
               coords = col.coords
               if len(coords) > 0:
                   # delete old MapAreas
                   for areas in self.ZopeFind(col, obj_metatypes=['MapArea']):
                       #area = areas[1]
                       id = areas[0]
                       print "  deleting: ", id
                       msg += "  deleting: "+id+"\n"
                       col._delObject(id)
                   # add new MapAreas
                   areacnt = 0
                   for coord in coords:
                       if len(coord) < 4:
                           continue
                       type = col.viewClassification
                       if type == 'view point':
                           type = 'arrow'
                       if type is None:
                           if len(coord) > 4:
                               type = 'arrow'
                           else:
                               type = 'area'
                       newid = "a%02d"%areacnt
                       areacnt += 1
                       area = MapArea(newid, coord, type=type)
                       print  "  adding: ", newid
                       msg += "  adding: "+newid+"\n"
                       col.addMapArea(area)
           msg += "\nDone!"
           return msg
   
   from ECHO_Nav import ECHO_navigation
   
   class ECHO_main(ECHO_root,ECHO_navigation):
       """echo main object combines ECHO_root and ECHO_navigation"""
       
       meta_type="ECHO_main"
       
       def __init__(self,id,title):
           """init"""
           self.id=id
           self.title=title
           self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.
           self.displayedMetaTypes=displayTypes
           
           
       manage_options = Folder.manage_options+(
           {'label':'Main Config','action':'ECHO_navigationConfigForm'},
           {'label':'Cache','action':'ECHO_cacheManageForm'},
           {'label':'Main Config','action':'ECHO_copyright_configForm'},
           {'label':'Change Weights','action':'changeWeights'},
           {'label':'Generate from RDF','action':'generateFromRDFForm'},
           {'label':'update Resource Catalog','action':'updateResourceCatalog'},
           {'label':'Copy MD for indexing and search','action':'copySearchFields'},
           )
   
       
   def manage_addECHO_mainForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)
       return pt()
   
   def manage_addECHO_main(self,id,title,RESPONSE=None):
       """Add an ECHO_main"""
       self._setObject(id,ECHO_main(id,title))
       
       obj=self._getOb(id)
       text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()
       
       manage_addPageTemplate(obj,'main_template',text=text)               
       
     
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
Removed from v.1.168  
changed lines
  Added in v.1.310.2.1

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>