[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.124 and 1.299

version 1.124, 2004/06/22 08:49:00 version 1.299, 2008/12/04 21:27:00
Line 9  class ECHO_externalLink contains informa Line 9  class ECHO_externalLink contains informa
   
   
 """  """
   try:
           from reportlab.pdfgen import canvas
           from reportlab.lib.pagesizes import A4
   except:
           print "PDF generation will not work"
        
   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.Image import Image  from OFS.Image import Image
 from Globals import DTMLFile  from Globals import DTMLFile
 from OFS.Folder import Folder  from OFS.Folder import Folder
Line 25  from Globals import DTMLFile Line 35  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
   from Products.MetaDataProvider.MetaDataClient import MetaDataClient
   import urllib
   import urllib2
   import cgi
   import smtplib
   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
   
 try:  try:
     from psycopg import libpq      from psycopg import libpq
Line 43  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 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)  
           
               
     return copyrightsFinal  
   
 #List of different types for the graphical linking viewer  
 viewClassificationListMaster=['view point','area']  
   
   
 def checkDiffs(self,metadict):  
         """check differences"""  
   
           
   
       
         def NoneToEmpty(obj):  
             if obj:  
                 return obj  
             else:  
                 return ""  
   
           
           
         diffs={}  
           
         tags=self.findTagsFromMapping(self.contentType)  
         self.referencetypes=tags[2]  
         self.fields=tags[3]  
           
       
         for field in tags[1]:  
             try:              try:
                 if (NoneToEmpty(self.getFieldValue(self.getFieldTag(tags,field)))==metadict[self.getFieldTag(tags,field)]):   from ECHO_language import *
                     diffs[self.getFieldTag(tags,field)]=1  
                 else:  
                       
                     diffs[self.getFieldTag(tags,field)]=0  
             except:              except:
                 diffs[self.getFieldTag(tags,field)]=0      print "no echo_language"
       class ECHO_language:
           """ leere Klasse"""
           pass
                                   
         return diffs  from ECHO_movie import *
   import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
   import xmlrpclib
           
 def content_html(self,type):  import logging
         """template fuer content"""  
         #templates = self.ZopeFind(self.aq_parent,obj_ids=[type+"_template"])  
         #  
         #if templates:  
         #    return templates[0][1]()  
           
         if hasattr(self,type+"_template"):  #ersetzt logging.info
             obj=getattr(self,type+"_template")  def logger(txt,method,txt2):
             return obj()      """logging"""
         else:      logging.info(txt+ txt2)
             pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_%s_template_standard.zpt'%type).__of__(self)  
             pt.content_type="text/html"  
             return pt()  
       
 def toList(field):  
     """Einzelfeld in Liste umwandeln"""  
     if type(field)==StringType:  
         return [field]  
     else:  
         return field  
           
 def getText(nodelist):  
   
     rc = ""  def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs=""):
     for node in nodelist:  
         if node.nodeType == node.TEXT_NODE:  
            rc = rc + node.data  
     return rc  
   
           """Allegemeine Informationen zu einer ECHO Collection"""
   
 def sendFile(self, filename, type):          self.label = label
     """sends an object or a local file (in the product) as response"""          self.title=title
     paths = filename.split('/')          self.description=description
     object = self          self.contentType=contentType
     # look for an object called filename          self.responsible=responsible
     for path in paths:          self.credits=toList(credits)
         if hasattr(object, path):          self.weight=weight
         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):  
     """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)  
   
               
     try:  
         geturl=""  
         for line in urllib.urlopen(url).readlines():  
             geturl=geturl+line  
           
           
     except:  
         return (None,"Cannot open: "+url)  
   
     try:  
         dom=xml.dom.minidom.parseString(geturl)  
     except:  
         return (None,"Cannot parse: "+url+"<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)  
   
   
   import ECHO_resource
           
   class ECHO_resource(ECHO_resource.ECHO_resource):
       """depricated use class in ECHO_resource.py"""
           
           
     if project:  class ECHO_partner(Image,Persistent,ECHO_basis):
         updateTextToolNode('project',project)      """ECHO Partner"""
   
     if startpage:      meta_type="ECHO_partner"
         updateTextToolNode('startpage',startpage)  
   
     if topbar:      def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):
         updateTextToolNode('toptemplate',topbar)          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)
   
     if thumbtemplate:      manage_options = Image.manage_options+(
         updateTextToolNode('thumbtemplate',thumbtemplate)          {'label':'Partner Information','action':'ECHO_partner_config'},
           )
   
     if xslt:  
         updateTextToolNode('xslt',xslt)  
   
       def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):
           """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')
           
           
     return dom.toxml().encode('utf-8')  
   
       def ECHO_partner_config(self):
           """Main configuration"""
           if not hasattr(self,'url'):
               self.url=""
           pt=zptFile(self, 'zpt/ChangeECHO_partner.zpt')
           return pt()
           
           
 def readMetadata(url):  manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
     """Methode zum Auslesen der Metadateninformation zu einer Resource                               Kind='ECHO_partner',kind='ECHO_partner')
     Vorerst noch Typ bib"""  
           
     metadict={}  
     try:  
         geturl=""  
         for line in urllib.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 372  class ECHO_copyright(Folder): Line 266  class ECHO_copyright(Folder):
         {'label':'Main Config','action':'ECHO_copyright_configForm'},          {'label':'Main Config','action':'ECHO_copyright_configForm'},
         )          )
   
   
     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 390  class ECHO_copyright(Folder): Line 285  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 407  def manage_addECHO_copyright(self, id,ti Line 302  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 415  class ECHO_layoutTemplate(ZopePageTempla Line 310  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 475  def manage_addECHO_layoutTemplate(self, Line 364  def manage_addECHO_layoutTemplate(self,
     REQUEST.RESPONSE.redirect(u+'/manage_main')      REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''      return ''
   
 class ECHO_resource(Folder,Persistent):  class ECHO_fullText(ZopePageTemplate,ECHO_basis,ECHO_language):
     """ECHO Ressource"""          """echo fulltext in xml"""
     security=ClassSecurityInfo()  
     meta_type='ECHO_resource'  
   
     viewClassificationList=viewClassificationListMaster  
   
     getSubCols = ECHO_helpers.getSubCols  
   
     def setStartPage(self,startpage=None,RESPONSE=None):  
         """set start page, if no startpage defined use the generic one of the resource"""  
   
         if not startpage:  
             startpage=self.absolute_url()+"/startpage_html"  
   
           
       
         params="startpage=%s"%startpage  
                                         
           meta_type="ECHO_fullText"
                   
         urllib.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()  
   
         path=self.metalink  
           
         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('/index.meta','',path)   
   
   
         print urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()  
   
         if RESPONSE is not None:  
             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"""  
                   
           def getPage(self,nr='1'):
                   """get page n"""
                   #return self().encode('latin-1','ignore')
         try:          try:
             dom=xml.dom.minidom.parse(self.metalink)                     dom=xml.dom.minidom.parseString(self())
             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:          except:
             return default                     dom=xml.dom.minidom.parseString(self().encode('latin-1'))
                      pages=dom.getElementsByTagName('page')
   
     def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,RESPONSE=None):  
         """changeit"""  
   
         paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate']                  return pages[int(nr)-1].toxml()
   
   # Product registration and Add support
   manage_addECHO_fullTextForm = PageTemplateFile(
       'zpt/AddECHO_fullText.zpt', globals())
                   
         #print writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate)  def manage_addECHO_fullText(self, id, title=None, text=None,
                              REQUEST=None, submit=None):
         params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate)      "Add a Page Template with optional file content."
   
           
         urllib.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()  
   
         # hack Pfad auf die Dokumente  
         path=self.metalink  
                   
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server      id = str(id)
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server      if REQUEST is None:
           self._setObject(id, ECHO_fullText(id, text))
           ob = getattr(self, id)
           if title:
               ob.pt_setTitle(title)
           return ob
       else:
           file = REQUEST.form.get('file')
           headers = getattr(file, 'headers', None)
           if headers is None or not file.filename:
               zpt = ECHO_fullText(id)
           else:
               zpt = ECHO_fullText(id, file, headers.get('content_type'))
   
         path=re.sub('/index.meta','',path)           self._setObject(id, zpt)
   
           try:
               u = self.DestinationURL()
           except AttributeError:
               u = REQUEST['URL1']
   
         print urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()          if submit == " Add and Edit ":
               u = "%s/%s" % (u, urllib.quote(id))
           REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
           
     def getTitle(self):  
     """title"""  
     return self.title.encode('utf-8')   
   
     def getLabel(self):  class ECHO_externalLink(Folder,ECHO_basis):
     """title"""      """Link zu einer externen Ressource"""
     return self.label.encode('utf-8')       security=ClassSecurityInfo()
       meta_type='ECHO_externalLink'
   
       security.declarePublic('content_html')
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return content_html(self,'resource')          ret= ECHO_basis.content_html(self,'externalLink')
       
     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=urllib.urlopen(self.metalink)  
             dom=xml.dom.minidom.parse(fh)  
             texttools=dom.getElementsByTagName('texttool')  
             text=texttools[0].getElementsByTagName('text')  
             texturl=getText(text[0].childNodes)  
             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
             if not noredirect:  
                 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 getCopyrightsHTML(self):  
         """gib (link auf copyright notiz, mediatyp, institution, copyrightType, label von copyrightType) aus"""  
           
         if hasattr(self,'copyrightModell'):  
             obj=self.copyrightModell  
                           
           if type(ret) is StringType:
               return ret.decode('utf-8')
         else:          else:
             return "ERROR"  
         ret=[]  
           
         for copyright in obj.getCopyrights():  
               
             link="copyrightTypes/"+copyright[2]+'/copyright.html'  
               
             try:  
                 copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])  
                 label=copyrightTypeObj.label  
                 url=copyrightTypeObj.url  
                   
                 if url!='':  
                      ret.append(("""<a target="_blank" href="%s">%s</a>"""%(url,label),copyright[0],copyright[1],copyright[2],label))  
                 else:  
                     if hasattr(copyrightTypeObj, 'copyright.html'):  
                          ret.append(("""<a target="_blank" href="%s?partner=%s">%s</a>"""%(link,copyright[1],label),copyright[0],copyright[1],copyright[2],label))  
                     else:  
                          ret.append((label,copyright[0],copyright[1],copyright[2],label))  
             except:  
                 """nothing"""  
               
         return ret          return ret
           
     def getCredits(self):  
         """Ausgabe der credits"""  
         if self.credits:  
             return self.credits  
         else:  
             return []  
           
     def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):      
       def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType):
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
                   
           self.credits=toList(credits)
         self.label = label          self.label = label
         self.link= link          self.link= link
         self.metalink=metalink  
         self.title=title          self.title=title
         self.weight=weight          self.weight=weight
         self.credits=toList(credits)  
         self.description=description          self.description=description
         self.contentType=contentType          self.contentType=contentType
     self.copyrightType=copyrightType  
     self.renderingType=renderingType  
         self.responsible=responsible          self.responsible=responsible
         self.resourceID=resourceID  
       
         if coords:  
             coordsnew=[ string.split(x,",") for x in coords]              coordsnew=[ string.split(x,",") for x in coords]
         else:  
             coordsnew=[]  
           
         self.coords=coordsnew          self.coords=coordsnew
           self.linkType = linkType        # Linktypen 'otherPresentation','external'
   
   
     def getCoords(self):      def ECHO_externalLink_config(self):
         """gibt coordinaten als String zurück und löscht zugleich einträge die keine Koordinaten sind, letzteres zur korrektur der Eingabe der alten version"""  
         retList=[]  
         if hasattr(self,'coords'):  
             for x in self.coords:  
             if len(x)>1:  
                 retList.append(string.join(x,","))  
         return retList  
   
       
   
     def getContentType(self):  
         try:  
             return self.contentType  
         except:  
             return ""  
   
     def getCopyrightType(self):  
         try:  
             return self.copyrightType  
         except:  
             return ""  
   
     def getRenderingType(self):  
         try:  
             return self.renderingType  
         except:  
             return ""  
   
     def ECHO_resource_config(self):  
         """Main configuration"""  
   
         if not hasattr(self,'weight'):  
             self.weight=""  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource.zpt').__of__(self)  
         return pt()  
       
   
     def ECHO_resource_config_main(self):  
         """Main configuration"""          """Main configuration"""
   
         if not hasattr(self,'weight'):          if not hasattr(self,'weight'):
             self.weight=""              self.weight=""
           if not hasattr(self,'coords'):
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_main.zpt').__of__(self)              self.coords=['']
         return pt()  
   
     def ECHO_resource_config_coords(self):  
         """Coords configuration """  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_coords.zpt').__of__(self)  
         return pt()  
   
     def ECHO_resource_config_credits(self):  
         """Main configuration"""  
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_credits.zpt').__of__(self)  
         return pt()  
   
     def ECHO_resource_config_metadata(self):  
         """Main configuration"""  
   
     if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):  
         self.metaDataHash={}  
         self.contentType=self.bib_type  
         for data in self.metadata:  
             data_neu=re.sub('-','_',data)  
             self.metaDataHash[data_neu]=getattr(self,data)[0:]  
   
           
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_resource_metadata.zpt').__of__(self)          pt=zptFile(self, 'zpt/ChangeECHO_externalLink.zpt')
         return pt()          return pt()
   
   
           def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
           """Aenderung der Properties"""
     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):          setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
         """Ä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.link=link
         self.metalink=metalink          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 changeECHO_resource_coords(self,coords,viewClassification,RESPONSE=None):      def setLinkType(self,type):
         """Änderung der Properties - coords"""          """ set linkType """
           self.linkType = type
     if type(coords)==StringType:  
             coords=[coords]  
   
       def checkLink(self):
           """ returns tuple (isWorking,Error) """        
         try:                  try:        
             coordsnew=[ string.split(x,",") for x in coords]              urllib2.urlopen(self.link)
               return (True, '')
           except urllib2.HTTPError, e:
               return (False, e.code)
           except urllib2.URLError, e:
               return (False, str(e.reason))
         except:          except:
         coordsnew=[]                  return (False, 'unknown Error')
   
     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):      manage_options = (
         """Änderung der Properties"""          {'label':'Main Config','action':'ECHO_externalLink_config'},
     self.credits=credits          {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
     self.responsible=responsible          )+Folder.manage_options
     self.copyrightType=copyrightType  
                   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
       def index_html(self):
           """standard page"""
   
     def changeECHO_resource_metadata_local(self,RESPONSE=None):          return self.REQUEST.RESPONSE.redirect(self.link)
         """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:]  
                           
   
   def manage_addECHO_externalLinkForm(self):
           """Form for external Links"""
           pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')
           return pt()
                                   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def changeECHO_resource_metadata(self,RESPONSE=None):  def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
         """change metadata"""      """Add an external Link"""
         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"""  
   
         urllib.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML')).read()      newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
   
       self._setObject(id,newObj)
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def getMDValue(self,fieldName):  class ECHO_link(ECHO_externalLink):
         return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)          """external_link"""
                        
     def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=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)  
         except:  
             return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate)  
   
     def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):          meta_type="ECHO_link"
         """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):          manage_options = ECHO_externalLink.manage_options+(
         """Änderung der Properties"""                  {'label':'add links config','action':'ECHO_link_addLinksForm'},
                   )
                   
     try:                  def ECHO_link_addLinksForm(self):
             coordsnew=[ string.split(x,",") for x in coords]              """Main configuration"""
         except:  
         coordsnew=[]      
                   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordsnew)              pt=zptFile(self, 'zpt/ChangeECHO_link_addLinks.zpt')
     self.viewClassification=viewClassification              return pt()
         self.coords=coordsnew[0:]  
         self.link=link  
         self.metalink=metalink  
                   
           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 content_html(self):
                   """template fuer link"""
                           
     manage_options = Folder.manage_options+(  
         {'label':'Main Config','action':'ECHO_resource_config_main'},  
     {'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','action':'changeViewerTemplateSetForm'},  
     )  
   
     def getOverview(self):  
         """overview graphics"""  
                   
         return self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['overview'])[0][1]                  if hasattr(self,"link_template"):
                           ret=ECHO_basis.content_html(self,'link')
   
     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:          else:
             return "NO OVERVIEW GRAPHICS"                          ret=ECHO_basis.content_html(self,'collection')
   
     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')  
   
                   #return ret
                   return ret
   #            
   #            
   #                try:
   #                    return ret.decode('utf-8')
   #                except:
   #                    try: 
   #                        return ret.decode('latin-1')
   #                    except:
   #                
   #                        return ret
   #        
           def getCopyrightsHTML(self):
               """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
   
     def isDefinedInThisSet(self,fields,field):              if hasattr(self,'copyrightModel'):
         """checks if field is defined in fields"""                      obj=self.copyrightModel
         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:              else:
                 return ret                      return "ERROR"
         except:              ret=[]
             return field  
   
               for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
   
   
     def getFieldTag(self,fields,field):  
         """get labels"""  
         try:          try:
             ret =fields[0][field]                          if hasattr(self.copyrightTypes,copyright[2]):
             if ret == "":                               copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
                 return field                               link="copyrightTypes/"+copyright[2]+'/copyright.html'
             else:              else:
                 return ret                               copyrightTypeObj=getattr(obj,copyright[2])
         except:                               link="copyrightModel/"+copyright[2]+'/copyright.html'
             return field  
   
                           label=copyrightTypeObj.label
                           url=getattr(copyrightTypeObj, 'url', '')
           
                                   if url!='':
     def getFieldValue(self,field):                                   ret.append((url,copyright[0],copyright[1],copyright[2],label))
         """get value"""  
       
         try:  
       
             ret=self.metaDataHash[field]  
             if ret == "":  
                 return None  
             else:              else:
                 return ret                                  if hasattr(copyrightTypeObj, 'copyright.html'):
                                        ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
                                   else:
                                        ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
         except:          except:
             return None                              """nothing"""
   
     def getMetaDataHash(self):              return ret
         """md hash"""  
         return self.metaDataHash  
           
     def setFieldValue(self,field,value):          def getInstitutionsHTML(self):
         """get value"""                  """gibt Liste der foerdernden Institutionen aus"""
           
     if not hasattr(self,'metaDataHash'):                  if hasattr(self,'support'):
         setattr(self,'metaDataHash',{})                          obj=self.support
     self.metaDataHash[field]=value[0:]                          ret=obj.getSupporter()
                           return ret
                   else:
                           return ''
           
           def getOwnerOriginalsHTML(self):
                  """gibt Liste der foerdernden Institutionen aus"""
   
                  if hasattr(self,'ownerOriginal'):
                          obj=self.ownerOriginal
                          ret=obj.getOwner()
                          return ret
                  else:
                          return ''
   
     def findLabelsFromMapping(self,referenceType):          def getDigiCopyByHTML(self):
         """gib hash mit label -> generic zurueck"""                 """gibt Liste der foerdernden Institutionen aus"""
     #return {},[]  
   
         temp=self.ZopeFind(self.standardMD)                 if hasattr(self,'digiCopyBy'):
                          obj=self.digiCopyBy
                          ret=obj.getDigiCopyBy()
                          return ret
                  else:
                          return ''
   
     if referenceType=="":          def index_html(self):
         referenceType="book"                  """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]
           
         bibdata={}  
         retdata={}  
     fields=[]  
         fieldlist=self.standardMD.fieldList  
                   
     for referenceTypeF in self.referencetypes:                   else:
                           params={}
   
         if referenceTypeF[1].title.lower() == referenceType.lower():                   if getattr(self,'addLinks','yes')=="yes":
                        params['backLink']=self.aq_parent.absolute_url()
                        params['startLink']=splitted[0]+"?"+urllib.urlencode(params)
   
             try:  
                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields  
                 referenceType=referenceTypeF[1].title  
             except:  
                 bibdata[referenceType]=referenceTypeF[1].fields  
                   
                    return self.REQUEST.RESPONSE.redirect(splitted[0]+"?"+urllib.urlencode(params))
                   else:
                    return ""
   
             bibdata['data']=referenceTypeF[1]  def manage_addECHO_linkForm(self):
             fields=bibdata[referenceType]          """Form for external Links"""
                         for field in fieldlist:          pt=zptFile(self, 'zpt/AddECHO_linkForm.zpt')
                             retdata[field]=referenceTypeF[1].getValue(field)[1]          return pt()
   
         return retdata,fieldlist,temp,fields  
   
     def findTagsFromMapping(self,referenceType):  def manage_addECHO_link(self,id,title,label,description="",contentType="",responsible="",link="",weight="",coords=[],credits=None,linkType="external",RESPONSE=None):
         """gib hash mit label -> generic zurueck"""      """Add an external Link"""
           
       newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
   
     if referenceType=="":      self._setObject(id,newObj)
         referenceType="book"  
           
     temp =  self.ZopeFind(self.standardMD)[0:]      getattr(self,id).addLinks='no'
   
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
           
     #self.referencetypes=temp[0:]  
           
   class ECHO_collection(CatalogAware, Folder, Persistent, Implicit, Cacheable,ECHO_basis):
       """ECHO Collection"""
           
       management_page_charset="utf-8"
       security=ClassSecurityInfo()
       meta_type='ECHO_collection'
       default_catalog='resourceCatalog'
           
   #    viewClassificationList=viewClassificationListMaster
       displayTypes=displayTypes
   
       path="/mpiwg/online/permanent/shipbuilding"
           
   
         bibdata={}      def exportImportObjects_html(self,RESPONSE):
         retdata={}          """ImportObject"""
         fieldlist=self.standardMD.fieldList          pt=zptFile(self, 'zpt/exportImportObjects.zpt')
           pt.content_type="text/html"
           return pt()
                   
     for referenceTypeF in temp:      def importObjects_html(self,RESPONSE):
           """ImportObject"""
           pt=zptFile(self, 'zpt/importObjects.zpt')
           pt.content_type="text/html"
           return pt()
           
         if referenceTypeF[1].title.lower() == referenceType.lower():       def importObjects(self,zfile,RESPONSE=None,REQUEST=None):
             try:          """import object from file"""
                 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          zf=zipfile.ZipFile(zfile,"r")
           tmpdir=tempfile.mkdtemp() # create tempdir
           ret=None
           
           for name in zf.namelist():
                  fn=tempfile.mkstemp()[1]
                  tf=file(fn,"w")
                  x=zf.read(name)
                  tf.write(x)
                  tf.close()
                  try:
                      self._importObjectFromFile(fn,set_owner=1)
                  except:
                      if not ret:
                          ret=""
                      ret+="Cannot import: %s (Already existing?)<br>"%name
                  os.remove(fn)
   
           if ret:
               return """<html><body>%s</body></html>"""%ret
           if RESPONSE:
               RESPONSE.redirect(self.absolute_url())
           
     security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination      def exportObjects_html(self,RESPONSE):
     def copyIndex_meta2echo_resource(self,RESPONSE=None):          """Export objects"""
         """copy MD von Index_meta to the echo_resource"""  
                   
         (metadict, error)=readMetadata(self.metalink)          pt=zptFile(self, 'zpt/exportObjects.zpt')
           pt.content_type="text/html"
           return pt()
   
         self.contentType=metadict['bib_type'][0:]      def exportObjects(self,ids,RESPONSE=None):
           """export objects with type id"""
           if not (type(ids) is ListType):
               ids=[ids]
                   
         self.metaDataHash={}          tmpdir=tempfile.mkdtemp() # create tempdir
         if not error=="": #Fehler beim Auslesen des Metafiles          objs=self.ZopeFind(self,obj_ids=ids)
             return "ERROR:",error          tmpfile=tempfile.mkstemp()[1]
         fields=self.findTagsFromMapping(self.contentType)  
                   
         #fields=self.findLabelsFromMapping(self.contentType)          zf=zipfile.ZipFile(tmpfile,"w")
         for field in fields[1]:          for obj in objs:
                           
             if self.isDefinedInThisSet(fields,field):              f = os.path.join(tmpdir, '%s.zexp' %obj[0])
                 #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))              #print E.absolute_url()
                 self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))  
   
               obj[1]._p_jar.exportFile(obj[1]._p_oid, f)
                   
               zf.write(f,obj[0])
                   
           zf.close()
           shutil.rmtree(tmpdir)
         if RESPONSE:          if RESPONSE:
             return RESPONSE.redirect('manage_main')              RESPONSE.setHeader("Content-Type","application/octet-stream")
                       len=os.stat(tmpfile)[6]
     def ECHO_getResourceMD(self,template="yes"):              RESPONSE.setHeader("Content-Length",len)
         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""              RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"export.zip")
         (metadict, error)=readMetadata(self.metalink)              fh=file(tmpfile)
               for x in fh.read():
                       RESPONSE.write(x)
               fh.close()
   
         if not error=="": #Fehler beim Auslesen des Metafiles      def getMDValueSimpleSearchField(self):
         return "ERROR:",error            """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',''))
   
     if not (metadict['bib_type'].lower()==self.contentType.lower()):      def localizeObjects(self):
         self.REQUEST.SESSION['contentStorage']=metadict['bib_type']              """localize all objects"""
         self.REQUEST.SESSION['contentZope']=self.contentType              contents=self.ZopeFind(self,obj_metatypes=['ECHO_externalLink','ECHO_link','ECHO_mapText'])
   
         return PageTemplateFile('Products/ECHO_content/zpt/ECHO_getResourceMDErrorContentType.zpt').__of__(self)()              find=self.ZopeFind(self,obj_ids=('locale_en'))
               if not find:
                   self.manage_addECHO_locale("en",'','')
               for content in contents:
   
     self.REQUEST.SESSION['metadict']=metadict                      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]
           
                                       locale=find[0][1].ZopeFind(find[0][1],obj_ids=('locale_en'))
                               else:
                                       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",'','')
           
     self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])              pt=zptFile(self, 'zpt/localizeObjects.zpt')
               return pt()
           
   
       def localize(self,REQUEST,RESPONSE):
               """localize"""
               for key in REQUEST.form.keys():
                       splitted=key.split("!")
                   
         if template=="yes":                      if splitted[0]=="" or splitted[0]=="en" or splitted[0]=="title" or splitted[0]=="label":
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_resourceMD.zpt').__of__(self)                              if splitted[0]=="en":
         return pt()                                      setattr(self.locale_en,splitted[1],REQUEST.form[key])
                               else:
                                       setattr(self,splitted[0],REQUEST.form[key])
                       else:
                               obj=getattr(self,splitted[0])
   
                               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:
                           RESPONSE.redirect('manage_main')
   
           
       def getRDF(self,urn=None):
               """rdf of the collection"""
           
     def ECHO_getMD(self,item):              contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
         """Ausgabe der MD"""  
         return getattr(self,item)  
                   
     def index_html(self):              ret=getRDFDescription(self,self.absolute_url(),urn=urn)
         """standard page"""  
                   
         return self.REQUEST.RESPONSE.redirect(self.link)              if not urn:
                       urn=self.absolute_url()
   
     def startpage_html(self):              li="""<RDF:li RDF:resource="%s" />\n"""
         """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'])              for content in contents:
                       ret+=content[1].getRDF()+"\n"
   
         if sp:              ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
             return sp[1]()              for content in contents:
                       nurn=content[1].absolute_url()
                       ret+=li%nurn
               return ret+"</RDF:Seq>"
   
             #prüfen ob irgendwo ein template  
         if hasattr(self,'startpage_index_template'):   
             return self.startpage_index_template()  
   
         #generisches template ausgeben  
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_startpage_index_template_standard.zpt').__of__(self)      def changeLabels(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeLabelsForm')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
     def toc_html(self):      def changeTitles(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeTitleForm')
                   pt.content_type="text/html"
                   return pt()
                   
         sp=self.ZopeFind(self,obj_ids=['toc.html'])      def changeWeights(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeWeightForm')
                   pt.content_type="text/html"
                   return pt()
                           
         if sp:      def changeMetaDataLinks(self):
             return sp[0][1]()                  """change form"""
                   pt=zptFile(self, 'zpt/changeMetaDataLinkForm')
                   pt.content_type="text/html"
                   return pt()
   
       def changeAccessRightsCollectionForm(self,preselect=None):
           """change access rights of all resources in this collection"""
   
     security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination          pt=zptFile(self, 'zpt/changeAccessRightsCollectionForm')
     def generate_label(self):          pt.content_type="text/html"
         """Erzeugt_standard_Label aus Template"""          return pt(preselect=preselect)
         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 changeAccessRightsCollection(self):
     def generate_title(self,RESPONSE=None):              """change"""
         """Erzeugt_standard_Label aus Template"""              ret=""
         pt=getattr(self,"label_template_"+self.contentType.lower())              argv=self.REQUEST.form
   
     self.title=pt()[0:]              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
               for resource in resources:
           
         return pt()                      if argv.has_key(resource[1].getId()+'_xml'):
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()+'_xml']+"</br>"
                               resource[1].setAccessRightXML(argv[resource[1].getId()+'_xml'])
                               resource[1].accessRight=argv[resource[1].getId()+'_xml']
                       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
   
 Globals.InitializeClass(ECHO_resource)      def changeMetaDataLinkInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
   
 def manage_addECHO_resourceForm(self):              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
         """Form for adding a ressource"""              for resource in resources:
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_resourceForm.zpt').__of__(self)  
         return pt()  
   
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].metalink=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
       def changeMetaDataLinkInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
   
 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):              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
     """addaresource"""              for resource in resources:
   
     newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)                      try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].metalink=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
     self._setObject(id,newObj)      def changeWeightsInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
   
     if RESPONSE is not None:              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         RESPONSE.redirect('manage_main')              for resource in resources:
     
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].weight=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
 class ECHO_externalLink(Folder):      def changeTitlesInCollection(self):
     """Link zu einer externen Ressource"""              """change all lables of a collection"""
     security=ClassSecurityInfo()              ret=""
     meta_type='ECHO_externalLink'              argv=self.REQUEST.form
   
     def getTitle(self):              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
     """title"""              for resource in resources:
     return self.title.encode('utf-8')   
   
     def getLabel(self):                      try:
     """title"""                              ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
     return self.label.encode('utf-8')                               resource[1].title=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
     def content_html(self):      def changeLabelsInCollection(self):
         """template fuer content"""              """change all lables of a collection"""
         return content_html(self,'externalLink')              ret=""
               argv=self.REQUEST.form
           
     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
               for resource in resources:
   
         self.id = id                      try:
         """Festlegen der ID"""                              ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].label=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
         self.credits=toList(credits)      def importCollection(self,path=None,RESPONSE=None):
         self.label = label          """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
         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):          if path is None:
         """Main configuration"""                  pt=zptFile(self, 'zpt/importCollection.zpt')
                   return pt()
   
         if not hasattr(self,'weight'):          files=os.listdir(path)
             self.weight=""          ret=""
         if not hasattr(self,'coords'):          for fileName in files:
                           
             self.coords=['']              if fileName:
   
                   tempPath=re.sub("/mpiwg/online","",path)
                   link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"
   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_externalLink.zpt').__of__(self)                  metalink=self.path+"/"+fileName+"/index.meta"
         return pt()                  try:
           
                           #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"
   
     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):                          newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'generated','book','','','','','','')
                           self._setObject(fileName,newObj)
   
         """Änderung der Properties"""                          genObj=getattr(self,fileName)
     try:                          #genObj.createIndexFile()
         coordsnew=[ string.split(x,",") for x in coords]                          ret+="OK:"+fileName+"<br/>"
     except:      except:
         coordsnew=[]                          print "ERROR"
                           ret+="ERROR:"+fileName+"<br/>"
   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coords)          return ret
   
         self.coords=coordsnew[0:]  
         self.link=link  
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
       def changeViewerTemplateSetsForm(self):
               """change the viewer template set"""
               pt=zptFile(self, 'zpt/changeViewerTemplateSet')
               return pt()
                           
     manage_options = Folder.manage_options+(      def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):
         {'label':'Main Config','action':'ECHO_externalLink_config'},              """Get the ViewerTemplateSet title for configuration"""
         )              ret=[]
   
                   
     def index_html(self):              try:
         """standard page"""                      viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.
                   
         return self.REQUEST.RESPONSE.redirect(self.link)                      for viewerTemplateSet in viewerTemplateSets:
                               ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))
   
 def manage_addECHO_externalLinkForm(self):                      return ret
         """Form for external Links"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_externalLinkForm.zpt').__of__(self)  
         return pt()  
   
               except:
                       return [('no ViewerTemplateSetfolders','')]
   
 def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):      def getTextToolsField(self,name,default=''):
     """Add an external Link"""              """Lese viewerTemplateSet der Collection not implemented yet!"""
   
     newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)              return default
   
     self._setObject(id,newObj)  
   
     if RESPONSE is not None:      def isSelectedViewerTemplateSet(self,obj,id):
         RESPONSE.redirect('manage_main')          """is ausgewaehlt"""
     
           if self.REQUEST['viewerTemplateSet']==id:
               return 1
           else:
               return None
   
 class ECHO_link(ECHO_externalLink):      def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):
     """external_link"""          """changes all ressources to the newViewer"""
   
     meta_type="ECHO_link"          resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
           if RESPONSE is not None:
                       RESPONSE.write("<html><body>")
           
           for resource in resources:
   
     def content_html(self):              done,msg=resource[1].changeViewer(newViewer)
         """template fuer link"""              if done:
         if hasattr(self,"link_template"):                  if RESPONSE is not None:
             return content_html(self,'link')                      RESPONSE.write("<p>OK: %s"%resource[0])
         else:          else:
             return content_html(self,'collection')                  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))
           
 def manage_addECHO_linkForm(self):  
         """Form for external Links"""  
         pt=PageTemplateFile('Products/ECHO_content/zpt/AddECHO_linkForm.zpt').__of__(self)  
         return pt()  
   
   
 def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):          if RESPONSE is not None:
     """Add an external Link"""                      RESPONSE.write("<p>Done</p></body></html>")
   
     newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)      def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
               """change the templates"""
   
     self._setObject(id,newObj)              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
               for resource in resources:
   
                       resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
   
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
   
 class ECHO_collection(Folder, Persistent, Implicit):      def setStartpageFolderForm(self):
     """ECHO Collection"""              """Form for changing the startpage"""
   
     security=ClassSecurityInfo()  
     meta_type='ECHO_collection'  
     viewClassificationList=viewClassificationListMaster  
     displayTypes=displayTypes  
   
   
     def changeViewerTemplateSetsForm(self):              pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPageFolder.zpt')
         """change the viewer template set"""              pt.content_type="text/html"
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeViewerTemplateSet').__of__(self)  
             return pt()              return pt()
   
     def getViewerTemplateSets(self,obj_ids=None):      def setStartpageFolder(self,startpage=None,RESPONSE=None):
         """Get the ViewerTemplateSet title for configuration"""              """change the templates"""
         ret=[]  
                   
         try:              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
             viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.  
                           
             for viewerTemplateSet in viewerTemplateSets:              for resource in resources:
                 ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))  
                                   
             return ret                      resource[1].setStartPage(startpage)
                           
         except:              if RESPONSE is not None:
             return [('no ViewerTemplateSetfolders','')]                      RESPONSE.redirect('manage_main')
   
     def getTextToolsField(self,name,default=''):      def copyTitleToInfoXMLFolder(self,RESPONSE=None):
         """Lese viewerTemplateSet der Collection not implemented yet!"""              """copy title into the title field of info.xml
               author and date werden leer!!!
               """
                   
         return default  
   
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
                           
     def isSelectedViewerTemplateSet(self,obj,id):  
         """is ausgewählt"""  
                   
         if self.REQUEST['viewerTemplateSet']==id:              for resource in resources:
             return 1                      ret,txt=resource[1].copyTitleToInfoXML()
         else:                      if (not ret) and RESPONSE:
             return None                              RESPONSE.write("error: %s\n"%txt)
                       if ret and RESPONSE:
                               RESPONSE.write("ok: %s\n"%txt)
   
     def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,RESPONSE=None):                      #logger("ECHO (copyTitleToInfoXMLFolder)",logging.INFO,txt)   
         """change the templates"""              if RESPONSE is not None:
                       RESPONSE.write("done!\n")
                       RESPONSE.close()
                       RESPONSE.redirect('manage_main')
   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])      def copySearchFields(self,RESPONSE=None):
               """copys < metadatafields to the object"""
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
         for resource in resources:          for resource in resources:
             print resource[0]  
             resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate)                      resource[1].copySearchFields()
   
         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=zptFile(self, 'zpt/reloadMetaDataFromStorageWarning.zpt')
               pt.content_type="text/html"
               return pt()
   
       def reloadMetaDataFromStorage(self,RESPONSE=None):
               """copy metadata from the storage to ECHO"""
   
               return reloadMetaDataFromStorage(self,RESPONSE)
   
   
     def getPartnerCopyright(self,name,sonst="generic"):      def getPartnerCopyright(self,name,sonst="generic"):
         """gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""          """gibt generisches copyright eines partners aus, sonst behalte jetzige einsteillung"""
Line 1345  class ECHO_collection(Folder, Persistent Line 1178  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"""  
     return self.title.encode('utf-8')   
   
     def getLabel(self):  
     """title"""  
     return self.label.encode('utf-8')   
   
           
                   
     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 1382  class ECHO_collection(Folder, Persistent Line 1208  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 1396  class ECHO_collection(Folder, Persistent Line 1225  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              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
           
           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 1418  class ECHO_collection(Folder, Persistent Line 1280  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"      def createAllJSAreas(self,mapColTypes=None):
         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):  
         """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 1543  class ECHO_collection(Folder, Persistent Line 1321  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 1564  class ECHO_collection(Folder, Persistent Line 1344  class ECHO_collection(Folder, Persistent
                     ret.append((label,link))                      ret.append((label,link))
         return ret          return ret
           
     security.declarePublic('ECHO_rerenderLinksMD')  
   
     def ECHO_rerenderLinksMD(self,obj=None):  
         """Rerender all Links"""  
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])  
   
         for entry in entries:  
         if entry[1].meta_type == 'ECHO_resource':  
             entry[1].ECHO_getResourceMD(template="no")  
             entry[1].generate_title()  
             entry[1].generate_label()  
   
         else:  
            self.ECHO_rerenderLinksMD(entry[1])  
   
                   
                   
         return "Rerenderd all links to resources in: "+self.title  
   
     security.declarePublic('ECHO_newViewerLink')  
       
   
     def getCoords(self):      def ECHO_rerenderLinksMDWarning(self):
         try:                  """change form"""
                   pt=zptFile(self, 'zpt/rerenderLinksWarning')
                   pt.content_type="text/html"
                   return pt()
                           
             x=  [string.join(x,",") for x in self.coords]    
             return x  
   
         except:  
   
             return []      security.declarePublic('ECHO_rerenderLinksMD')
       def ECHO_rerenderLinksMD(self,obj=None,types=['title','label']):
           """Rerender all Links"""
           return ECHO_rerenderLinksMD(self,obj,types)
                   
     def __init__(self,id,title,label,description,contentType,responsible,credits,weight,sortfield,coords,secondaryLinkTitle,secondaryLink,imageTag="",bgcolour=""):  
   
       def __init__(self,id,title,label,description="",contentType="",responsible="",credits="",weight="",sortfield="",coords=[],secondaryLinkTitle="",secondaryLink="",imageTag="",bgcolour="",isVisible=True):
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
Line 1618  class ECHO_collection(Folder, Persistent Line 1377  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+(      manage_options = Folder.manage_options+ Cacheable.manage_options+(
         {'label':'Main Config','action':'ECHO_collection_config'},          {'label':'Main Config','action':'ECHO_collection_config'},
         {'label':'Rerender Links','action':'ECHO_rerenderLinksMD'},          {'label':'Change Labels','action':'changeLabels'},
         {'label':'Graphics','action':'ECHO_graphicEntry'},          {'label':'Change Titles','action':'changeTitles'},
           {'label':'Localize','action':'localizeObjects'},
           {'label':'Change Weights','action':'changeWeights'},
           {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},
           {'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':'Change Viewer Templates','action':'changeViewerTemplateSetsForm'},          {'label':'Set Startpage','action':'setStartpageFolderForm'},
           {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},
           {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
           {'label':'ImportCollection','action':'importCollection'},
           {'label':'Copy MD for indexing and search','action':'copySearchFields'},
           {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},
         )          )
   
     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 1667  class ECHO_collection(Folder, Persistent Line 1409  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 1684  class ECHO_collection(Folder, Persistent Line 1420  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):                  
       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.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():
               
               result = self.ZCacheable_get()
               if result is not None:
                   # Got a cached value.
                   return result
                   
         if 'index.html' in self.__dict__.keys():          if 'index.html' in self.__dict__.keys():
             return getattr(self,'index.html')()              ret=getattr(self,'index.html')()
                   
         elif 'overview' in self.__dict__.keys():          elif 'overview' in self.__dict__.keys():
             return self.showOverview()              ret=self.showOverview()
         elif hasattr(self,'collection_index_template'):          elif hasattr(self,'collection_index_template'):
             return self.collection_index_template()                  ret=self.collection_index_template()    
         elif hasattr(self,'main_index_template'):          elif hasattr(self,'main_index_template'):
             return self.main_index_template()      
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/ECHO_main_index_template_standard.zpt').__of__(self)              ret=self.main_index_template.__of__(self)(self.main_template)
           else:
               pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()              ret=pt.render()
   
     def content_html(self):          self.ZCacheable_set(ret)
           return ret
   
       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 1767  class ECHO_collection(Folder, Persistent Line 1523  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 1829  class ECHO_group(ECHO_collection): Line 1591  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_rerenderLinksMD'},                  {'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 getRDF(self,urn=None):
               """rdf of the collection"""
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
   
               ret=getRDFDescription(self,self.absolute_url(),urn=urn)
   
               
               if not urn:
                       urn=self.absolute_url()
               li="""<RDF:li RDF:resource="%s" />\n"""
               
               
               for content in contents:
                       ret+=content[1].getRDF()+"\n"
                       
               ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
               for content in contents:
                       nurn=content[1].absolute_url()
                       ret+=li%nurn
               return ret+"</RDF:Seq>"
               
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
         displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)          displayedObjects=self.ZopeFind(self,obj_metatypes=displayTypes)
Line 1852  class ECHO_group(ECHO_collection): Line 1637  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 1868  class ECHO_group(ECHO_collection): Line 1653  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 1880  class ECHO_group(ECHO_collection): Line 1665  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 1903  class ECHO_group(ECHO_collection): Line 1681  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 2043  def manage_addECHO_userFolderForm(self): Line 1822  def manage_addECHO_userFolderForm(self):
     """add a user folder form"""      """add a user folder form"""
     return manage_addECHO_userFolder(self)      return manage_addECHO_userFolder(self)
   
   
   
   def createNode(self,descrs,node):
           name=descrs[node]['name']
           type=descrs[node]['type']
           urn=node
           #print "    will create",node.encode('utf-8')
           id=re.sub('[^a-zA-Z0-9]','',name).encode('ascii','ignore')
           #print "id",id
           #print type
           #self.REQUEST.RESPONSE.write("<p>%s<p>\n"%id)
           if type=="CDLI_group":
                   
                   try:
                           manage_addECHO_collection(self,id,name,name,"","","","","")
                   
                   except:
                           self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
                           
                   self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
                   
                   return type,getattr(self,id),urn
   
           if type=="CDLI_item":
                   try:
                           manage_addECHO_resource(self,id,name,name,"","",urn,"","")
                   except:
                           self.REQUEST.RESPONSE.write("<p>Error%s</p>\n"%id)
                   self.REQUEST.RESPONSE.write("<p>Creates:%s</p>\n"%getattr(self,id).absolute_url())
                   
                   
           return "XX"
   
   
 class ECHO_root(Folder,Persistent,Implicit):  class ECHO_root(Folder,Persistent,Implicit):
     """ECHO Root Folder"""      """ECHO Root Folder"""
   
     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':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
                   {'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 getECHORootURL(self):
           return self.absolute_url()
       
       def getECHORoot(self):
           return self
       
       def copySearchFields(self,RESPONSE=None):
               """copys < metadatafields to the object"""
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
               for resource in resources:
   
                       resource[1].copySearchFields()
   
               if RESPONSE is not None:
                       RESPONSE.redirect('manage_main')
      
       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):
           #print "getTablet"
           try:
                   read=urllib.urlopen("http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"%item).read()
                   read=re.sub("\[search\]","search",read)
                   return read[read.find("<body>")+6:read.rfind("</body>")]
           except:
                   return "<h1>Sorry no connection to the data server enlil.museum.upenn.edu</h1>"
           #return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"
       ###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):
                   """change form"""
                   pt=zptFile(self, 'zpt/generateFromRDFForm')
                   pt.content_type="text/html"
                   return pt()
   
       def generateFromRDF(self,file,startNode="/Cuneiform Corpus"):
   
               """generate from RDF"""
   
               global seqs
               seqs={}
               global descrs
               descrs={}
               global key
               key=""
               global value
               value=""
   
               def getEdges(seqs,urn):
                       """edges"""
                       ret=[]
                       return seqs[urn]
   
               def createSubs(self,seqs,descrs,urn,level=0):
                       """create subs"""
                       for edge in getEdges(seqs,urn):
                               cn=createNode(self,descrs,edge)
                               if cn[0]=="CDLI_group":
                                       createSubs(cn[1],seqs,descrs,cn[2],level+1)
                       return
   
               def start_element(name,attrs):
   
                       global seqs
                       global descrs
                       global key
                       global value
                       seq=""
                       if name=="RDF:Seq":
                               key=attrs.get('RDF:about')
                               try: # teste ob liste
                                       x=seqs[key][0]
                               except:
   
                                       seqs[key]=[]
   
                       
                       elif name=="RDF:Description":
                               key=attrs.get('RDF:about')
                               
   
                       elif name=="RDF:li":
                               name=attrs.get('RDF:resource')
                               seqs[key].append(name)
   
                       elif name=="ECHONAVIGATION:type":
                               value="type"
   
                       elif name=="ECHONAVIGATION:name":
                               value="name"
                       elif name=="ECHONAVIGATION:linkClickable":
                               value="linkClickable"
                               
               def end_element(name):
                               """nothing"""
                               key=""
                               value=""
   
               def char_data(data):
                       """nothing"""
   
                       data=re.sub("\n","",data)
                       try:
                               if descrs[key].has_key(value):
                                       descrs[key][value]+=data
                               else:
                                       descrs[key][value]=data
                       except:
   
                               descrs[key]={}
                               descrs[key][value]=data
                               
               p = xml.parsers.expat.ParserCreate()
               
               p.StartElementHandler = start_element
               p.EndElementHandler = end_element
               p.CharacterDataHandler = char_data
               
               
               p.ParseFile(file)
               self.REQUEST.RESPONSE.write("<html><body><h1>Start</h1>")
               createSubs(self,seqs,descrs,startNode)
               self.REQUEST.RESPONSE.write("<h1>done</h1></body></html>")
               #print "done"
   
               
               return "done"
       
               
   
                   
       def changeWeightsInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].weight=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
   
       def changeWeights(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/changeWeightForm')
                   pt.content_type="text/html"
                   return pt()
     
   
       def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
               """warning"""
               pt=zptFile(self, 'zpt/reloadMetaDataFromStorageWarning.zpt')
               pt.content_type="text/html"
               return pt()
   
       def reloadMetaDataFromStorage(self,RESPONSE=None):
               """reload MD from Storage"""
   
               return reloadMetaDataFromStorage(self,RESPONSE)
       
       def getRDF(self,urn=None):
               """rdf of the collection"""
   
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
   
               ret=getRDFDescription(self,self.absolute_url(),urn=urn)
               
               li="""<RDF:li RDF:resource="%s" />\n"""
   
               
               for content in contents:
                       ret+=content[1].getRDF()+"\n"
                       
               ret+="""<RDF:Seq RDF:about="%s">\n"""%urn
               for content in contents:
                       nurn=content[1].absolute_url()
                       ret+=li%nurn
               return ret+"</RDF:Seq>"
               
   
       def showContent(self,path):
               """return content/html"""
               
               return ECHO_helpers.urlopen(path+"/content_html").read()
       
       def getImageViewers(self):
           """images"""
           viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])
           return viewers
   
   
     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 2063  class ECHO_root(Folder,Persistent,Implic Line 2191  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('utf-8','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 2080  class ECHO_root(Folder,Persistent,Implic Line 2212  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 2122  class ECHO_root(Folder,Persistent,Implic Line 2255  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,selected=None,first=None):      def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):
          """give type selector"""           """give type selector"""
   
      if not first:       if not first:
Line 2161  class ECHO_root(Folder,Persistent,Implic Line 2277  class ECHO_root(Folder,Persistent,Implic
                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])                   retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
              else:                               else:                
                  retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])                   retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])
                    
                    for copyrightTypeSelf in self.ZopeFind(object,obj_metatypes=["ECHO_copyrightType"],search_sub=1):
                            if selected and (copyrightTypeSelf[0]==selected):
                                    retStr+="""<option selected value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
                            else:                
                                    retStr+="""<option value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])
                                    
      except:       except:
          """nothing"""           """nothing"""
                    
      return retStr       return retStr
   
     def partnerSelector_HTML(self,selected=None):      def partnerSelector_HTML(self,selected=None):
Line 2182  class ECHO_root(Folder,Persistent,Implic Line 2306  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 2222  class ECHO_root(Folder,Persistent,Implic Line 2346  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 2254  class ECHO_root(Folder,Persistent,Implic Line 2383  class ECHO_root(Folder,Persistent,Implic
                                   
         return "changed all contenttypes in: "+self.title          return "changed all contenttypes in: "+self.title
   
       def deleteCache(self,obj=None,RESPONSE=None):
           """setze alle collections auf cache = CacheManager"""
           if not obj:
               obj = self
           entries=obj.ZopeFind(obj,search_sub=1)
           for entry in entries:
                   if hasattr(entry[1],'_v_hash'):
                           entry[1]._v_hash=None
           
           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 2292  class ECHO_root(Folder,Persistent,Implic Line 2434  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 2304  class ECHO_root(Folder,Persistent,Implic Line 2449  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)
               return unicodify(str)
         else:          else:
             return ""              return u""
           
     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")  
                 if self.checkRef(ref):  
                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)  
   
             newxml=dom.toxml('utf-8')  
         match=re.sub(r'<\?xml version=\"1.0\" encoding=\"utf-8\"\?>\n<txt>','',newxml)  
         match=re.sub(r'</txt>','',match)  
                   
         return match      link2html=vlp_xmlhelpers.link2html
       related2html=vlp_xmlhelpers.related2html
                                 
         return ""      xml2html=vlp_xmlhelpers.xml2html
    
     def xml2html(self,str):      checkRef=vlp_xmlhelpers.checkRef
         """link2html fuer VLP muss hier noch raus"""      
         if str:  #    def checkRef(self,ref):
   #            if ref[0:3]=='lit':
             str=re.sub("\&","&amp;",str)  #                    if len(self.library_data({ 'id':ref}))>0:
             dom=xml.dom.minidom.parseString(str)  #                            return 1
             links=dom.getElementsByTagName("link")  #            try:
               #                    if ref[0:7]=="tec_cat":
   #                            return 1
             for link in links:  #            except:
                 link.tagName="a"  #                    """nothing"""
                 ref=link.getAttribute("ref")  #                    
                 if self.checkRef(ref):  #            dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''}
                     link.setAttribute("href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)  #            res=None
   #            for db in dbs.keys():
             return dom.toxml('utf-8')  #                    res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
         return ""  #            return res
   #                                    
     def checkRef(self,ref):  #    #Ende Methode fuer vlp
         dbs={'vl_literature':'AND CD LIKE \'%lise%\'','vl_technology':'','vl_people':''}  
         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'):            
                   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 []
                                           
         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]      def getInstitutions(self):
                           """Get list of Partners. Presently only from a subfolder partners"""
                   
                                         
           return [ item[1] for item in self.institutions.ZopeFind(self.institutions,obj_metatypes=['ECHO_institution'])]
   
           
     def getPartnersXML(self):      def getPartnersXML(self):
Line 2380  class ECHO_root(Folder,Persistent,Implic Line 2508  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 2461  class ECHO_root(Folder,Persistent,Implic Line 2589  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 2487  class ECHO_root(Folder,Persistent,Implic Line 2629  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 resource[1].getFullTextXML(noredirect="yes"):                      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'):
                     viewer_url=echo_url+"/getMetaDataXML"                              meta_url=echo_url+"/getMetaDataXML"
                 else:  
                     viewer_url="NO URL"  
                 if filter:  
                     if re.search(filter,viewer_url):  
                         ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
                 else:                  else:
                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))                              meta_url="NO_URL"
         ret +="""\n</index>"""  
                   
                       if filter and not re.search(filter,viewer_url):
                               continue
   
                       #modificationDate=time.strptime(str(resource[1].bobobase_modification_time()),"%Y/%m/%d %H:%M:%S %Z")
                       
                       modificationDate=resource[1].bobobase_modification_time().strftime("%Y/%m/%d %H:%M:%S")
   
                       ret+="""\n<resource resourceLink="%s" metaLink="%s" modificationDate="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'),modificationDate)
                       
                               
               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 2525  class ECHO_root(Folder,Persistent,Implic Line 2683  class ECHO_root(Folder,Persistent,Implic
         par=self.ZopeFind(self.partners, obj_ids=[id])          par=self.ZopeFind(self.partners, obj_ids=[id])
         return par          return par
   
       def getInstitutionFromID(self,id):
           """ find institution from id """
           inst=self.ZopeFind(self.institutions, obj_ids=[id])
           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 2536  def manage_addECHO_root(self,id,title,RE Line 2737  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 2557  class ECHO_copyrightType(Folder): Line 2758  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 2572  class ECHO_copyrightType(Folder): Line 2773  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 2588  def manage_addECHO_copyrightType(self,id Line 2789  def manage_addECHO_copyrightType(self,id
     
   
     
 class ECHO_partner(Image,Persistent):  
     """ECHO Partner"""  
   
     meta_type="ECHO_partner"  class ECHO_linkList(ZopePageTemplate,ECHO_basis):
       """LinkList Objekt"""
       meta_type="ECHO_linkList"
   
       _default_content_fn = os.path.join(package_home(globals()), 'html/ECHO_pageTemplateDefault.html')
   
       manage_options = ZopePageTemplate.manage_options+(
           {'label':'Main Config','action':'changeECHO_linkListWeightForm'},
           )
   
       def content_html(self):
           """content_html"""
           return ECHO_basis.content_html(self,'pageTemplate')
   
       def changeECHO_linkListWeightForm(self):
           """change"""
           pt=zptFile(self, 'zpt/ChangeECHO_linkListTemplate.zpt')
           return pt()
   
       def changeECHO_linkListWeight(self,contentType,label,RESPONSE=None):
           """change"""
           self.contentType=contentType
           self.label=label
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def getLabel(self):
           if hasattr(self,'label'):
               return self.label.encode('utf-8')
           else:
               return 0
           
       def getcontentType(self):
           """get contentType"""
           if hasattr(self,'contentType'):
               return normalizeCt(self.contentType)
           else:
               return 0
   
       def __init__(self, id, label, title=None, text=None, contentType=None):
            self.id = str(id)
            self.title=title
            self.label=label
            self.ZBindings_edit(self._default_bindings)
            if text is None:
                text = ''
            if content_type is None:
                content_type = self.content_type
            self.pt_edit(text, contentType)
   
   
   
   
   def manage_addECHO_linkListForm(self):
       """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_linkListTemplate.zpt')
       return pt()
   
   
   def manage_addECHO_linkList(self, id, label,contentType=0,title=None, text=None,
                              REQUEST=None, submit=None):
       """Add a LinkList with optional file content."""
       
       id = str(id)
       if REQUEST is None:
           self._setObject(id, ECHO_linkList(id, label, text))
           ob = getattr(self, id)
           setattr(ob,'contentType',contentType)
           if title:
               ob.pt_setTitle(title)
           return ob
       else:
           file = REQUEST.form.get('file')
           headers = getattr(file, 'headers', None) 
           if (headers is None) or (not file.filename):
               zpt = ECHO_linkList(id, file)
           else:
               zpt = ECHO_linkList(id, label,'', file, headers.get('contentType'))
   
     def __init__(self, id, title,url, file, copyrightType, person, email, country, content_type='', precondition=''):          self._setObject(id, zpt)
           ob = getattr(self, id)
           if title:
               ob.pt_setTitle(title)
           
           try:
               u = self.DestinationURL()
           except AttributeError:
               u = REQUEST['URL1']
   
           if submit == " Add and Edit ":
               u = "%s/%s" % (u, urllib.quote(id))
           REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
       
   
   class ECHO_support(Folder,ECHO_basis):
           """gefoerdert durch"""
           meta_type="ECHO_support"
           
           
           
           def __init__(self,id,institutions=None):
                   """init"""
                   self.id=id
                   self.title=''
                   self.institutions=toList(institutions)
   
           def getSupporter(self):
                   """return institutions"""
                   if self.institutions:
                           return self.institutions
                   else:
                           return []
                   
           manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_support_configForm'},
                   )
   
           def ECHO_support_configForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_support')
                   pt.content_type="text/html"
                   return pt()
   
           def ECHO_support_config(self,institutions=None,RESPONSE=None):
                   """change"""
                   self.institutions=toList(institutions)
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
                   
   def manage_addECHO_supportForm(self):
       """Form for adding"""
       pt=zptFile(self, 'zpt/AddECHO_support.zpt')
       return pt()
   
   def manage_addECHO_support(self, id,institutions=None,RESPONSE=None):
           """add the copyright"""
   
           meta_type="ECHO_support"
           
           
           self._setObject(id, ECHO_support(id,institutions))
   
           if RESPONSE is not None:
                   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')
   
                   
   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"""
   
       meta_type="ECHO_institution"
   
       def __init__(self, id, title,url, file, person, email, country, content_type='', precondition=''):
         self.__name__=id          self.__name__=id
         self.title=title          self.title=title
         self.url=url          self.url=url
Line 2601  class ECHO_partner(Image,Persistent): Line 3066  class ECHO_partner(Image,Persistent):
         self.email=email          self.email=email
         self.country=country          self.country=country
         self.precondition=precondition          self.precondition=precondition
         self.copyrightType=copyrightType  
         data, size = self._read_data(file)          data, size = self._read_data(file)
         content_type=self._get_content_type(file, data, id, content_type)          content_type=self._get_content_type(file, data, id, content_type)
         self.update_data(data, content_type, size)          self.update_data(data, content_type, size)
   
     manage_options = Image.manage_options+(      manage_options = Image.manage_options+(
         {'label':'Partner Information','action':'ECHO_partner_config'},          {'label':'Institution Information','action':'ECHO_institution_config'},
         )          )
   
           
     def changeECHO_partner(self,url,copyrightType,person, email, country, RESPONSE=None):      def changeECHO_institution(self,url,person, email, country,RESPONSE=None):
         """Change main information"""          """Change main information"""
         self.url=url          self.url=url
         self.person=person          self.person=person
         self.email=email          self.email=email
         self.country=country          self.country=country
         self.copyrightType=copyrightType  
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
                           
   
     def ECHO_partner_config(self):      def ECHO_institution_config(self):
         """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_partner.zpt').__of__(self)          pt=zptFile(self, 'zpt/ChangeECHO_institution.zpt')
         return pt()          return pt()
   
                   
 manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),  manage_addECHO_institutionForm=DTMLFile('dtml/ECHO_institutionAdd',globals(),
                              Kind='ECHO_partner',kind='ECHO_partner')                               Kind='ECHO_institution',kind='ECHO_institution')
   
   
   
 def manage_addECHO_partner(self, id,file,url, person, email, country, copyrightType='', title='', precondition='', content_type='',  def manage_addECHO_institution(self, id, url, person, email, country, file=None, title='', precondition='', content_type='',
                     REQUEST=None):                      REQUEST=None):
     """      """
     Add a new ECHO_partner object.      Add a new ECHO_institution object.
   
     Creates a new ECHO_partner object 'id' with the contents of 'file'.      Creates a new ECHO_institution object 'id' with the contents of 'file'.
     Based on Image.manage_addImage      Based on Image.manage_addImage
     """      """
   
Line 2655  def manage_addECHO_partner(self, id,file Line 3118  def manage_addECHO_partner(self, id,file
     self=self.this()      self=self.this()
   
     # First, we create the image without data:      # First, we create the image without data:
     self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, content_type, precondition))      self._setObject(id, ECHO_institution(id,title,url,'', person, email, country, content_type, precondition))
   
     # Now we "upload" the data.  By doing this in two steps, we      # Now we "upload" the data.  By doing this in two steps, we
     # can use a database trick to make the upload more efficient.      # can use a database trick to make the upload more efficient.
Line 2670  def manage_addECHO_partner(self, id,file Line 3133  def manage_addECHO_partner(self, id,file
         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':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
           {'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.124  
changed lines
  Added in v.1.299

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