[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.205 and 1.310.2.8

version 1.205, 2005/01/21 17:32:09 version 1.310.2.8, 2012/08/29 07:53:31
Line 1 Line 1
 """New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""  """New version of the produc started February, 8th. Without scientific classification, use content-type for further classification."""
 """Echo collection provides the classes for the ECHO content web-site.  """Echo collection provides the classes for the ECHO content web-site.
   
 class ECHO_collection is the basis class for an ECHO collection.  class ECHO_collection is the basis class for an ECHO collection.
Line 9  class ECHO_externalLink contains informa Line 9  class ECHO_externalLink contains informa
   
   
 """  """
 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 tempfile
   import zipfile
 import re  import re
 import os  import os,shutil
 import OFS.Image  import OFS.Image
 from types import *  from types import *
 from OFS.Cache import Cacheable  from OFS.Cache import Cacheable
Line 34  from Globals import DTMLFile Line 31  from Globals import DTMLFile
 import Globals  import Globals
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate,manage_addPageTemplate
 from Globals import Persistent, package_home  from Globals import Persistent, package_home
 from Acquisition import Implicit  from Acquisition import Implicit
   from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
   import ECHO_helpers
   from Acquisition import aq_parent
   try:
       from Products.MetaDataProvider.MetaDataClient import MetaDataClient
   except:
       print "no metadataclient"
 import urllib  import urllib
   import urllib2
   import cgi
 import smtplib  import smtplib
 import time  import time
 from Ft.Xml.Domlette import NonvalidatingReader  #from Ft.Xml.Domlette import NonvalidatingReader
 from Ft.Xml.Domlette import PrettyPrint  #from Ft.Xml.Domlette import PrettyPrint, Print
 from Ft.Xml import EMPTY_NAMESPACE  #from Ft.Xml import EMPTY_NAMESPACE
   #
 import Ft.Xml.XPath  #import Ft.Xml.XPath
 import cStringIO  import cStringIO
 import zLOG  
   import sys
   import logging
   
 try:  try:
     from psycopg import libpq      from psycopg import libpq
Line 63  import urllib Line 71  import urllib
 import xml.dom.minidom  import xml.dom.minidom
 import ECHO_helpers  import ECHO_helpers
 from ECHO_helpers import *  from ECHO_helpers import *
 from ECHO_language import *  
   
   try:
    from ECHO_language import *
   except:
       print "no echo_language"
       class ECHO_language:
           """ leere Klasse"""
           pass
   
 #regexp for extracting elements from xml  from ECHO_movie import *
 patternTXT=r"<\s*txt.*?>(.*?)</txt>"  #import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
 regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL)  import xmlrpclib
 patternPage=r"<\s*page.*?>(.*?)</page>"  
 regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL)  import logging
   
   from ECHO_root  import ECHO_root
   
   #ersetzt logging.info
   def logger(txt,method,txt2):
       """logging"""
       logging.info(txt+ txt2)
                   
   
 def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs=""):  def setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight,coordstrs=""):
Line 86  def setECHO_collectionInformation(self,t Line 106  def setECHO_collectionInformation(self,t
         self.credits=toList(credits)          self.credits=toList(credits)
         self.weight=weight          self.weight=weight
   
   import ECHO_resource
   from ECHO_resource import manage_addECHO_resource
   
   class ECHO_resource(ECHO_resource.ECHO_resource):
       """depricated use class in ECHO_resource.py"""
   
   
   class ECHO_partner(Image,Persistent,ECHO_basis):
       """ECHO Partner"""
   
       meta_type="ECHO_partner"
   
       def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):
           self.__name__=id
           self.title=title
           self.url=url
           self.person=person
           self.email=email
           self.country=country
           self.color=color
           self.precondition=precondition
           self.copyrightType=copyrightType
           data, size = self._read_data(file)
           content_type=self._get_content_type(file, data, id, content_type)
           self.update_data(data, content_type, size)
   
       manage_options = Image.manage_options+(
           {'label':'Partner Information','action':'ECHO_partner_config'},
           )
   
       
       def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):
           """Change main information"""
           self.url=url
           self.person=person
           self.email=email
           self.country=country
           self.color=color
           self.copyrightType=copyrightType
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
               
               
   
       def ECHO_partner_config(self):
           """Main configuration"""
           if not hasattr(self,'url'):
               self.url=""
           pt=zptFile(self, 'zpt/ChangeECHO_partner.zpt')
           return pt()
   
           
   manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),
                                Kind='ECHO_partner',kind='ECHO_partner')
   
   
   
   def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',
                       REQUEST=None):
       """
       Add a new ECHO_partner object.
   
       Creates a new ECHO_partner object 'id' with the contents of 'file'.
       Based on Image.manage_addImage
       """
   
       id=str(id)
       title=str(title)
       content_type=str(content_type)
       precondition=str(precondition)
   
       id, title = OFS.Image.cookId(id, title, file)
   
       self=self.this()
   
       # First, we create the image without data:
       self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))
   
       # Now we "upload" the data.  By doing this in two steps, we
       # can use a database trick to make the upload more efficient.
       if file:
           self._getOb(id).manage_upload(file)
       if content_type:
           self._getOb(id).content_type=content_type
   
       if REQUEST is not None:
           try:    url=self.DestinationURL()
           except: url=REQUEST['URL1']
           REQUEST.RESPONSE.redirect('%s/manage_main' % url)
       return id
   
   class ECHO_locale(ZopePageTemplate):
           """localisierung"""
   
           meta_type="ECHO_locale"
   
           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
   
           manage_options = ZopePageTemplate.manage_options+(
                   {'label':'Main Config','action':'change_ECHO_localeForm'},
                   )
   
           def change_ECHO_localeForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_localeForm.zpt')
                   return pt()
           
           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.label=label
                   if not text is None:
                           if content_type is None:
                               content_type = self.content_type
                           self.pt_edit(text, content_type)
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
                   
   def manage_addECHO_localeForm(self):
            """Form for adding"""
            pt=zptFile(self, 'zpt/AddECHO_localeForm.zpt')
            return pt()
   
   def manage_addECHO_locale(self,lang,title,label,text=None,content_type=None,RESPONSE=None):
           """add echo locale"""
   
           id="locale_"+lang
           
           self._setObject(id, ECHO_locale(id,lang,title,label,text,content_type))
           if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
   
                           
 class ECHO_copyright(Folder,ECHO_basis):  class ECHO_copyright(Folder,ECHO_basis):
     """Copyright informationen"""      """Copyright informationen"""
Line 153  class ECHO_layoutTemplate(ZopePageTempla Line 317  class ECHO_layoutTemplate(ZopePageTempla
   
         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)
   
   
Line 212  class ECHO_fullText(ZopePageTemplate,ECH Line 377  class ECHO_fullText(ZopePageTemplate,ECH
           
     def getPage(self,nr='1'):      def getPage(self,nr='1'):
         """get page n"""          """get page n"""
                   #return self().encode('latin-1','ignore')
                   try:
         dom=xml.dom.minidom.parseString(self())          dom=xml.dom.minidom.parseString(self())
                   except:
                      dom=xml.dom.minidom.parseString(self.utf8ify(self()))
         pages=dom.getElementsByTagName('page')          pages=dom.getElementsByTagName('page')
                   
         return pages[int(nr)-1].toxml('utf-8')                  return pages[int(nr)-1].toxml()
           
 # Product registration and Add support  # Product registration and Add support
 manage_addECHO_fullTextForm = PageTemplateFile(  manage_addECHO_fullTextForm = PageTemplateFile(
Line 253  def manage_addECHO_fullText(self, id, ti Line 422  def manage_addECHO_fullText(self, id, ti
     return ''      return ''
   
   
 class ECHO_resource(Folder,Persistent,ECHO_basis):  
     """ECHO Ressource"""  
     security=ClassSecurityInfo()  
     meta_type='ECHO_resource'  
   
 #    viewClassificationList=viewClassificationListMaster  
   
     getSubCols = ECHO_helpers.getSubCols  
   
     security.declareProtected('View','index_html')  
   
       
     
     security.declareProtected('View','createPDF')  
     def createPDF(self,RESPONSE=None,local=None,dpi=150):  
         """erzeuge pdf file"""  
         pages=1  
         dpi=float(dpi)  
         imagePath=self.getImagePath().replace("/mpiwg/online","")  
           
           
         image="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn="+imagePath+"&dw=%i&dh=%i&pn=%i"  
         xmlInfo="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/dlInfo-xml.jsp?fn="+imagePath  
   
         dom=xml.dom.minidom.parse(urllib.urlopen(xmlInfo))  
         for parameter in dom.getElementsByTagName('parameter'):  
             if parameter.getAttribute('name')=="pt":  
                 pages=int(parameter.getAttribute('value'))  
                 break  
           
   
         tempdir="/tmp/archivesImageServer"  
         if not os.path.exists(tempdir):  
             os.mkdir(tempdir)   
     
         tmpPath=tempfile.mkdtemp(dir=tempdir)  
           
   
         tmpZip=tempfile.mktemp(dir=tempdir)  
   
         tmpFn=os.path.split(tmpZip)[1]  
   
   
       
   
         if RESPONSE:  
             RESPONSE.setHeader("Content-Type","text/html")  
             RESPONSE.write("<h1>I am creating  the pdf</h1>")  
             txt="<h3>1. step: getting the images( %i pages)</h3>"%pages  
             RESPONSE.write(txt)  
   
         c=canvas.Canvas(tmpZip)  
         for i in range(1,pages+1):  
             if RESPONSE:  
                 RESPONSE.write(str("<p>Get Page: %i<br>\n"%i))  
             faktor=dpi/72.0  
               
             fn=tmpPath+"/%i"%i  
   
             width,height=A4  
             #print image%(width*faktor,height*faktor,i)  
             url=urllib.urlopen(image%(width*faktor,height*faktor,i)).read()  
             fh=file(fn,"w")  
             fh.write(url)  
             fh.close()  
   
       
   
             c.drawImage(fn,0,0,width=width,height=height)  
             c.showPage()  
         c.save()  
         if RESPONSE:  
             RESPONSE.write("<p>finished<br>\n")  
   
         if RESPONSE:  
             len=os.stat(tmpZip)[6]  
             downloadUrl=self.absolute_url()+"/downloadPDF"  
             RESPONSE.write("""<h1><a href="downloadPDF?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len))  
             RESPONSE.write("""<p>The file will be stored for a while, you can download it later, the URL is:</p>  
             <p><a href="downloadPDF?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn))  
             RESPONSE.close()  
   
   
     def downloadPDF(self,fn):  
         """download prepared set"""  
         filename="/tmp/archivesImageServer/"+fn  
         namePDF=self.getId()+".pdf"  
         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%namePDF)  
         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")  
         len=os.stat(filename)[6]  
         self.REQUEST.RESPONSE.setHeader("Content-Length",len)  
         images=file(filename).read()  
         self.REQUEST.RESPONSE.write(images)  
         self.REQUEST.RESPONSE.close()  
   
   
     def getRDF(self,urn=None):  
         """rdf"""  
         ret=getRDFDescription(self,self.link,urn=urn)  
         return ret+self.createSubElementRDF(urn=urn)   
   
     
     def getAccessRightSelectorHTML(self,outlook="select"):  
         """htmlselector"""  
         values=['free','mpiwg']  
                   
         if outlook=="select":  
             ret="""<select name="%s">"""%self.getId()  
   
             for value in values:  class ECHO_externalLink(Folder,ECHO_basis):
                 if value==self.getAccessRightMD():      """Link zu einer externen Ressource"""
                     ret+="<option selected>%s</option>"%value      security=ClassSecurityInfo()
                 else:      meta_type='ECHO_externalLink'
                     ret+="<option>%s</option>"%value  
             return ret+"</select>"  
   
         else:      security.declarePublic('content_html')
             ret=""      def content_html(self):
             for value in values:          """template fuer content"""
           ret= ECHO_basis.content_html(self,'externalLink')
                                   
                 if value==self.getAccessRightMD():          if type(ret) is StringType:
                     ret+="""<input type="radio" name="%s" value="%s" checked>%s"""%(self.getId(),value,value)              return ret.decode('utf-8')
                 else:                  else:
                     ret+="""<input type="radio" name="%s" value="%s">%s"""%(self.getId(),value,value)  
             return ret              return ret
   
   
           
     def getAccessRightMD(self):      def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType):
         """set accessright"""  
         url=self.metalink  
   
         try:  
             geturl=""  
             for line in ECHO_helpers.urlopen(url).readlines():  
                 geturl=geturl+line  
   
   
         except:  
             return (None,"Cannot open: "+url)  
   
         try:          self.id = id
             dom=xml.dom.minidom.parseString(geturl)          """Festlegen der ID"""
             root=dom.getElementsByTagName('resource')[0]  
         except:  
             return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
         internal=dom.getElementsByTagName('internal')  
         if internal:  
             institution=dom.getElementsByTagName('institution')  
             return getText(institution[0].childNodes)  
                   
         free=dom.getElementsByTagName('free')          self.credits=toList(credits)
         if free:          self.label = label
             return "free"          self.link= link
           self.title=title
           self.weight=weight
           self.description=description
           self.contentType=contentType
           self.responsible=responsible
           coordsnew=[ string.split(x,",") for x in coords]
           self.coords=coordsnew
           self.linkType = linkType        # Linktypen 'otherPresentation','external'
   
         return "free" #default free  
   
     def changeAccessRightMD(self,accessright,RESPONSE=None):      def ECHO_externalLink_config(self):
         """change the rights"""          """Main configuration"""
                   
         params="accessright=%s"%accessright          if not hasattr(self,'weight'):
               self.weight=""
           if not hasattr(self,'coords'):
   
               self.coords=['']
   
         #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()  
   
           pt=zptFile(self, 'zpt/ChangeECHO_externalLink.zpt')
           return pt()
                   
         ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/setAccessRightXML'+urllib.quote('?'+params))).read()  
   
       def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
           """Aenderung der Properties"""
           setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
               
           self.link=link
           self.linkType = linkType
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
               def getLinkType(self):
     def setAccessRightXML(self,accessright):          """ return linkType """
         """set accessright"""          if hasattr(self,"linkType"):
         url=self.metalink                  return self.linkType
   
         try:  
             geturl=""  
             for line in ECHO_helpers.urlopen(url).readlines():  
                 geturl=geturl+line   
   
   
         except:  
             return (None,"Cannot open: "+url)  
   
         try:  
             dom=xml.dom.minidom.parseString(geturl)  
             root=dom.getElementsByTagName('resource')[0]  
         except:  
             return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
         metanodes=dom.getElementsByTagName('access-conditions')  
   
         if not metanodes:  
             nodenew=dom.createElement('access-conditions')  
             root.appendChild(nodenew)  
             metanode=nodenew  
         else:          else:
             metanode=metanodes[0]                  return 'otherPresentation'
   
         accesses=metanode.getElementsByTagName('access')      def setLinkType(self,type):
           """ set linkType """
         if not accesses:          self.linkType = type
             nodenew2=dom.createElement('access')  
             metanode.appendChild(nodenew2)  
             metanode2=nodenew2  
         else:  
             metanode2=accesses[0]  
   
         internal=metanode.getElementsByTagName('internal')  
   
         if internal:  
             metanode2.removeChild(internal[0]).unlink()  
   
         free=metanode.getElementsByTagName('free')  
           
         if free:  
             metanode2.removeChild(internal[0]).unlink()  
   
   
         if accessright=='free':  
             nodenew3=dom.createElement('free')  
             metanode2.appendChild(nodenew3)  
         elif accessright=='mpiwg':  
             nodenew3=dom.createElement('internal')  
             nodenew4=dom.createElement('institution')  
             metanodetext=dom.createTextNode('mpiwg')  
             nodenew4.appendChild(metanodetext)  
             nodenew3.appendChild(nodenew4)  
             metanode2.appendChild(nodenew3)  
   
         return dom.toxml().encode('utf-8')  
   
     def setStartPageForm(self):  
         """Form for changing the startpage"""  
   
           
         pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPage.zpt')  
             pt.content_type="text/html"  
             return pt()  
       
   
     def createImageUrl(self,pn=1):  
         """create ImageUrl"""  
   
           
         resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')  
           
         digiliburlprefix=readFieldFromXML(self.metalink,'texttool','digiliburlprefix')  
         images=readFieldFromXML(self.metalink,'texttool','image')  
   
   
         if (not resourcepath) or (not digiliburlprefix) or (not images):  
             zLOG.LOG("ECHO (createImageUrl)",zLOG.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())  
             return None  
         resourcepath=resourcepath.replace('/mpiwg/online','')  
         if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"  
   
         if (not images) or (not resourcepath): return None  
   
         return "%sfn=%s&pn=%i"%(digiliburlprefix,resourcepath+"/"+images,pn)  
       
     def copyTitleToInfoXML(self,RESPONSE=None):  
         """copy title from the resource"""  
         presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')  
         resourcepath=readFieldFromXML(self.metalink,'resource','archive-path')  
         if (not presentationXML) or (not resourcepath):   
         if RESPONSE:  
             RESPONSE.write("Error: %s\n"%self.getId())  
         else:  
             return None,self.absolute_url()  
   
       def checkLink(self):
           """ returns tuple (isWorking,Error) """        
         try:          try:
             fh=file(os.path.join(resourcepath,presentationXML),'w')              urllib2.urlopen(self.link)
             fh.write("""<info>              return (True, '')
             <author></author>          except urllib2.HTTPError, e:
             <title>%s</title>              return (False, e.code)
             <date></date>          except urllib2.URLError, e:
             <display>yes</display>              return (False, str(e.reason))
             </info>"""%self.title)  
             fh.close()  
             return 1,self.getId()  
         except:          except:
             if RESPONSE:              return (False, 'unknown Error')
                 RESPONSE.write("Error: %s\n"%self.getId())  
             else:  
                 return None,self.absolute_url()  
   
                   
     def setStartPage(self,startpage=None,RESPONSE=None):      manage_options = (
         """set start page, if no startpage defined use the generic one of the resource"""          {'label':'Main Config','action':'ECHO_externalLink_config'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         if (not (type(startpage)==StringType)):          )+Folder.manage_options
             if ("__generic" in startpage): # checke ob generic in der liste  
                 startpage=self.absolute_url()+"/startpage_html"  
             elif ("__firstPage" in startpage): # checke ob generic in der liste  
                 startpage=self.createImageUrl()  
                                   
         if (not startpage):  
             startpage=self.absolute_url()+"/startpage_html"  
         elif (startpage=="__generic"):  
             startpage=self.absolute_url()+"/startpage_html"  
         elif (startpage=="__firstPage"):  
                 startpage=self.createImageUrl()  
           
         params="startpage=%s"%startpage      def index_html(self):
         print '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))          """standard page"""
                                                                                                                                     
         ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()          return self.REQUEST.RESPONSE.redirect(self.link)
           
                   
         path=self.metalink  def manage_addECHO_externalLinkForm(self):
           """Form for external Links"""
           pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')
           return pt()
                   
         path=re.sub(self.REQUEST['SERVER_URL'],'',path)  
         path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)  
                   
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server      """Add an external Link"""
         path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server  
             path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server  
         path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server  
         path=re.sub('http://vision.mpiwg-berlin.mpg.de','',path) # falls vision als server  
         path=re.sub('http://xserve02.mpiwg-berlin.mpg.de:18880','',path) # falls vision als server  
         path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo  
         path=re.sub('/index.meta','',path)   
   
       newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
   
         ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()      self._setObject(id,newObj)
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def changeViewerTemplateSetForm(self):  
         """change the viewer template set"""  
         pt=zptFile(self, 'zpt/changeResourceViewerTemplateSet')  
             return pt()  
   
   
      
     def getTextToolsField(self,name,default=''):  
         """Lese Textoolsfelder aus index.meta im path aus"""  
           
         try:  
             dom=xml.dom.minidom.parse(self.metalink)  
             node=dom.getElementsByTagName('texttool')[0] #getNode  
             subnode=node.getElementsByTagName(name)[0]  
   
             # bei text wird nur der Folder gebraucht  
             if name=="text":  
                 splitted=getText(subnode.childNodes).split("/")  
                 return splitted[len(splitted)-2]  
             else:  
                 return getText(subnode.childNodes)  
         except:  
             return default  
      
   
     def changeViewerTemplateSet(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):  
         """changeit"""  
   
         paramList=['project','startpage','xslt','thumbtemplate','topbar','digiLibTemplate','digiliburlprefix']  
   
           
         #writeMetadata(self.metalink,self.metaDataHash,project,None,xslt,thumbtemplate,topbar,digiLibTemplate)  
   
         params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)  
   
           
         ECHO_helpers.urlopen('http://echo.mpiwg-berlin.mpg.de/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()  
   
         #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)  class ECHO_link(ECHO_externalLink):
         # hack Pfad auf die Dokumente          """external_link"""
         path=self.metalink  
           
           
   
         path=re.sub('/index.meta','',path)   
   
         path=re.sub(self.REQUEST['SERVER_URL'],'',path)  
         path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)  
   
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  
         path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server  
   
         path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server          meta_type="ECHO_link"
         path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server  
         path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server  
         path=re.sub('http://echo.mpiwg-berlin.mpg.de','',path) # falls echo  
   
         path=re.sub('http://vision.rz-berlin.mpg.de','',path) # falls vision als server          manage_options = ECHO_externalLink.manage_options+(
                   {'label':'add links config','action':'ECHO_link_addLinksForm'},
                   )
   
         return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()          def ECHO_link_addLinksForm(self):
               """Main configuration"""
   
               pt=zptFile(self, 'zpt/ChangeECHO_link_addLinks.zpt')
               return pt()
   
           def ECHO_link_addLinks(self,addLinks,RESPONSE):
               """add links"""
               self.addLinks=addLinks
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
       
   
       
     def content_html(self):      def content_html(self):
         """template fuer content"""                  """template fuer link"""
         return ECHO_basis.content_html(self,'resource')  
       
 #    def getViewClassification(self):  
 #        if hasattr(self,'viewClassification'):  
 #            return self.viewClassification  
 #        else:  
 #            return ""  
   
     def getFullTextXML(self,noredirect=None):  
         """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""  
   
         try:  
             #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"open %s"%self.metalink)  
             fh=ECHO_helpers.urlopen(self.metalink)  
             #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"opened %s"%self.metalink)  
             dom=xml.dom.minidom.parse(fh)  
             texttools=dom.getElementsByTagName('texttool')  
             text=texttools[0].getElementsByTagName('text')  
             texturl=getText(text[0].childNodes)  
   
             #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"found %s"%texturl)  
                     fh.close()  
             #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"closed fh")  
             #keine url  
             if not (texturl.split(":")[0] in ['http','ftp','file']):   
             if not noredirect:  
                 return file(texturl).read()  
                         else:  
                 return texturl  
   
             if not noredirect:  
                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')    
                     zLOG.LOG("ECHO Fulltext",zLOG.INFO,"redirect to:%s"%texturl)  
                 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 getImagePath(self):  
         """gibt pfad zum image aus"""  
         return self.getImageView(noredirect="yes",onlyPath="yes")  
       
     def getImageView(self,noredirect=None,onlyPath=None):  
         """getImages; give Imageviewr  and <error></error> if somthing goes wrong."""  
         try:  
             fh=ECHO_helpers.urlopen(self.metalink)  
             dom=xml.dom.minidom.parse(fh)  
             texttools=dom.getElementsByTagName('texttool')  
             text=texttools[0].getElementsByTagName('image')  
             imagetemp=getText(text[0].childNodes)  
                           
             text=dom.getElementsByTagName('archive-path')  
             archivepath=getText(text[0].childNodes)  
             archivepath=re.sub('/mpiwg/online/','',archivepath)   
             imageurl="http://echo.mpiwg-berlin.mpg.de/zogilib?fn="+archivepath+"/"+imagetemp  
             fh.close()  
   
             if not noredirect:                  if hasattr(self,"link_template"):
                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')                            ret=ECHO_basis.content_html(self,'link')
                 self.REQUEST.RESPONSE.redirect(imageurl)  
             else:  
                 if not onlyPath:  
                     return imageurl  
                 else:  
                     return archivepath+"/"+imagetemp  
         except:  
   
             if not noredirect:  
                 self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
                 self.REQUEST.RESPONSE.write("<error>no fulltext available</error>")  
             else:              else:
                 return "<error>no images available</error>"                          ret=ECHO_basis.content_html(self,'collection')
   
           
                   #return ret
                   return ret
   #            
   #            
   #                try:
   #                    return ret.decode('utf-8')
   #                except:
   #                    try: 
   #                        return ret.decode('latin-1')
   #                    except:
   #                
   #                        return ret
   #        
     def getCopyrightsHTML(self):      def getCopyrightsHTML(self):
         """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""          """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
                   
Line 784  class ECHO_resource(Folder,Persistent,EC Line 626  class ECHO_resource(Folder,Persistent,EC
         else:          else:
             return ''              return ''
                           
           def getOwnerOriginalsHTML(self):
                  """gibt Liste der foerdernden Institutionen aus"""
           
     def getCredits(self):                 if hasattr(self,'ownerOriginal'):
         """Ausgabe der credits"""                         obj=self.ownerOriginal
         if self.credits:                         ret=obj.getOwner()
             return self.credits                         return ret
         else:          else:
             return []                         return ''
   
           def getDigiCopyByHTML(self):
                  """gibt Liste der foerdernden Institutionen aus"""
   
                  if hasattr(self,'digiCopyBy'):
                          obj=self.digiCopyBy
                          ret=obj.getDigiCopyBy()
                          return ret
                  else:
                          return ''
           
     def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):          def index_html(self):
                   """standard link"""
                   if self.link:
                    splitted=self.link.split("?")
                    if len(splitted)>1:
                           params=cgi.parse_qs(splitted[1])
   
         self.id = id                          for x in params.keys():
         """Festlegen der ID"""                                  if type(params[x]) is ListType:
                                           params[x]=params[x][0]
                   
         self.label = label  
         self.link= link  
         self.metalink=metalink  
         self.title=title  
         self.weight=weight  
         self.credits=toList(credits)  
         self.description=description  
         self.contentType=contentType  
     self.copyrightType=copyrightType  
     self.renderingType=renderingType  
         self.responsible=responsible  
         self.resourceID=resourceID  
           
         if coords:  
             coordsnew=[ string.split(x,",") for x in coords]  
         else:          else:
             coordsnew=[]                          params={}
                   
         self.coords=coordsnew                   if getattr(self,'addLinks','yes')=="yes":
 #   self.viewClassification=""                       params['backLink']=self.aq_parent.absolute_url()
                        params['startLink']=splitted[0]+"?"+urllib.urlencode(params)
   
   
                    return self.REQUEST.RESPONSE.redirect(splitted[0]+"?"+urllib.urlencode(params))
     def getContentType(self):                  else:
         try:  
             return self.contentType  
         except:  
             return ""  
   
     def getCopyrightType(self):  
         try:  
             return self.copyrightType  
         except:  
             return ""  
   
     def getRenderingType(self):  
         try:  
             return self.renderingType  
         except:  
             return ""              return ""
   
     def ECHO_resource_config(self):  def manage_addECHO_linkForm(self):
         """Main configuration"""          """Form for external Links"""
           pt=zptFile(self, 'zpt/AddECHO_linkForm.zpt')
         if not hasattr(self,'weight'):  
             self.weight=""  
   
         pt=zptFile(self, 'zpt/ChangeECHO_resource.zpt')  
         return pt()  
       
   
     def ECHO_resource_config_main(self):  
         """Main configuration"""  
         if not hasattr(self,'weight'):  
             self.weight=""  
         pt=zptFile(self, 'zpt/ChangeECHO_resource_main.zpt')  
         return pt()  
   
     def ECHO_resource_config_coords(self):  
         """Coords configuration """  
         pt=zptFile(self, 'zpt/ChangeECHO_resource_coords.zpt')  
         return pt()  
   
     def ECHO_resource_config_credits(self):  
         """Main configuration"""  
         pt=zptFile(self, 'zpt/ChangeECHO_resource_credits.zpt')  
         return pt()  
   
     def ECHO_resource_config_metadata(self):  
         """Main configuration"""  
     if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):  
         self.metaDataHash={}  
         self.contentType=self.bib_type  
         for data in self.metadata:  
             data_neu=re.sub('-','_',data)  
             self.meta  
                         DataHash[data_neu]=getattr(self,data)[0:]  
   
       
         pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')  
         return pt()          return pt()
   
   
   def manage_addECHO_link(self,id,title,label,description="",contentType="",responsible="",link="",weight="",coords=[],credits=None,linkType="external",RESPONSE=None):
       """Add an external Link"""
           
       newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
   
     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):      self._setObject(id,newObj)
         """Aenderung der Properties"""  
     self.resourceID=resourceID  
     self.title=title  
     self.label=label  
     self.description=description  
   
     self.contentType=contentType  
     self.renderingType=renderingType  
     self.weight=weight  
       
         self.link=link  
         self.metalink=metalink  
           
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
   
     def changeECHO_resource_coords(self,RESPONSE=None):  
         """Aenderung der Properties - coords"""  
     #return self.REQUEST  
     for area in self.getMapAreas():  
         id = area.getId()  
         if self.REQUEST.has_key('del.'+id):  
         # delete this area  
         self._delObject(id)  
         # return to same menu  
         if RESPONSE is not None:  
             RESPONSE.redirect('ECHO_resource_config_coords')  
         return  
         # modify this area  
         coordstring = self.REQUEST.get('coords.'+id, '')  
         coords = string.split(coordstring, ',')  
         angle = self.REQUEST.get('angle.'+id, '0')  
         type = self.REQUEST.get('type.'+id, 'area')  
         if len(coords) == 4:  
         area.setCoordString(coordstring)  
         area.setAngle(angle)  
         area.setType(type)  
     # return to main menu      
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
   
     def changeECHO_resource_credits(self,credits,responsible,copyrightType,RESPONSE=None):  
         """Aenderung der Properties"""  
     self.credits=credits  
     self.responsible=responsible  
     self.copyrightType=copyrightType  
           
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
   
     def changeECHO_resource_metadata_local(self,RESPONSE=None):  
         """change metadata"""  
         tags=self.findTagsFromMapping(self.contentType)  
         for field in tags[1]:  
             self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]  
               
   
                   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def changeECHO_resource_metadata(self,RESPONSE=None):  
         """change metadata"""  
         tags=self.findTagsFromMapping(self.contentType)  
         self.OSAS_meta={}  
         for field in tags[1]:  
             try:  
                 self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]  
                 self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]  
             except:  
                 """nothing"""  
   
         ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML')).read()  
   
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
   
     def getMDValue(self,fieldName,empty=None):  
         if empty:  
             return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)  
           
         else:  
             return self.metaDataHash.get(fieldName,empty)  
           
     def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):  
         """new index.meta"""  
         self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
   
         if not hasattr(self,'metaDataHash'):  
           
             self.copyIndex_meta2echo_resource()  
         try:  
             return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)  
         except:  
             return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)  
   
     def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):  
         """schreibe md"""  
           
         try:  
               
             return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")  
         except:  
             return "<error> no metadata stored</error>"  
       
     def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):  
         """prints out metadata as stored in the echo environment, format is the index.meta format"""  
         self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
         return writeMetadata(self.metalink,self.metaDataHash)  
   
     def changeECHO_resource(self,metalink,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):  
         """Aenderung der Properties"""  
                   
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)      getattr(self,id).addLinks='no'
         self.link=link  
         self.metalink=metalink  
                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
                           
     manage_options = Folder.manage_options+(  class ECHO_collection(CatalogAware, Folder, Persistent, Implicit, Cacheable,ECHO_basis):
         {'label':'Main Config','action':'ECHO_resource_config_main'},      """ECHO Collection"""
     {'label':'Change Metadata','action':'ECHO_resource_config_metadata'},  
     {'label':'Graphic Coords','action':'ECHO_graphicEntry'},  
         {'label':'Sync Metadata','action':'ECHO_getResourceMD'},  
     {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},  
     {'label':'set/change startpage','action':'setStartPageForm'},  
     {'label':'Copy MD for indexing and search','action':'copySearchFields'},  
     )  
   
   
     def isDefinedInThisSet(self,fields,field):  
         """checks if field is defined in fields"""  
         if (fields[0].has_key(field)) and not (fields[0][field]==""):  
             return 1  
         else:  
             
             return 0  
           
     def getFieldLabel(self,fields,field):  
         """get labels"""  
         try:  
             ret =fields[0][field]  
             if ret == "":  
                 return field  
             else:  
                 return ret  
         except:  
             return field  
   
   
   
     def getFieldTag(self,fields,field):  
         """get labels"""  
         try:  
             ret =fields[0][field]  
             if ret == "":  
                 return field  
             else:  
                 return ret  
         except:  
             return field  
   
       
           
     def getFieldValue(self,field):  
         """get value"""  
       
         try:  
       
             ret=self.metaDataHash[field]  
             if ret == "":  
                 return None  
             else:  
                 return ret  
         except:  
             return None  
   
     def getMetaDataHash(self):  
         """md hash"""  
         return self.metaDataHash  
       
     def setFieldValue(self,field,value):  
         """get value"""  
       
     if not hasattr(self,'metaDataHash'):  
         setattr(self,'metaDataHash',{})  
     self.metaDataHash[field]=value[0:]  
       
   
     def copySearchFields(self):  
         """copys metadatafields to the object"""  
         fields=['author','title','year']  
         for field in fields:  
             setattr(self,'MD_'+field,self.getFieldValue(field))  
       
   
     def findLabelsFromMapping(self,referenceType):  
         """gib hash mit label -> generic zurueck"""  
     #return {},[]  
   
         temp=self.ZopeFind(self.standardMD)  
   
     if referenceType=="":  
         referenceType="book"  
       
       
         bibdata={}  
         retdata={}  
     fields=[]  
         fieldlist=self.standardMD.fieldList  
   
         tags=self.findTagsFromMapping(self.contentType)  
     self.referencetypes=tags[2]  
     for referenceTypeF in self.referencetypes:  
   
         if referenceTypeF[1].title.lower() == referenceType.lower():  
   
             try:  
                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields  
                 referenceType=referenceTypeF[1].title  
             except:  
                 bibdata[referenceType]=referenceTypeF[1].fields  
           
   
             bibdata['data']=referenceTypeF[1]  
             fields=bibdata[referenceType]  
                         for field in fieldlist:  
                             retdata[field]=referenceTypeF[1].getValue(field)[1]  
   
         return retdata,fieldlist,temp,fields  
   
     def findTagsFromMapping(self,referenceType):  
         """gib hash mit label -> generic zurueck"""  
       
   
     if referenceType=="":  
         referenceType="book"  
       
     temp =  self.ZopeFind(self.standardMD)[0:]  
   
       
     #self.referencetypes=temp[0:]  
       
       
       
   
       
   
         bibdata={}  
         retdata={}  
         fieldlist=self.standardMD.fieldList  
         fields=[]  
     for referenceTypeF in temp:  
         #print referenceType  
       
         if referenceTypeF[1].title.lower() == referenceType.lower():   
             try:  
                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields  
                 referenceType=referenceTypeF[1].title  
             except:  
                 bibdata[referenceType]=referenceTypeF[1].fields  
             bibdata['data']=referenceTypeF[1]  
             fields=bibdata[referenceType]  
                         for field in fieldlist:  
                             retdata[field]=referenceTypeF[1].getValue(field)[0]  
       
         return retdata,fieldlist,temp,fields  
   
       
     security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination  
     def copyIndex_meta2echo_resource(self,RESPONSE=None):  
         """copy MD von Index_meta to the echo_resource"""  
           
         (metadict, error)=readMetadata(self.metalink)  
   
   
           
         self.metaDataHash={}  
         if not error=="": #Fehler beim Auslesen des Metafiles  
               
             return "ERROR:",error,self.absolute_url()  
           
         self.contentType=metadict['bib_type'][0:]  
         fields=self.findTagsFromMapping(self.contentType)  
           
         #fields=self.findLabelsFromMapping(self.contentType)  
         for field in fields[1]:  
               
             if self.isDefinedInThisSet(fields,field):  
                 #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))  
                 self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))  
   
           
           
         if RESPONSE:  
             return RESPONSE.redirect('manage_main')  
           
     def ECHO_getResourceMD(self,template="yes",back=None):  
         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""  
         (metadict, error)=readMetadata(self.metalink)  
   
         if back:  
             self.REQUEST.SESSION['back']=back  
   
         if not error=="": #Fehler beim Auslesen des Metafiles  
         return "ERROR:",error  
       
   
     if not (metadict['bib_type'].lower()==self.contentType.lower()):  
         self.REQUEST.SESSION['contentStorage']=metadict['bib_type']  
         self.REQUEST.SESSION['contentZope']=self.contentType  
   
         return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()  
   
     self.REQUEST.SESSION['metadict']=metadict  
   
           
       management_page_charset="utf-8"
       security=ClassSecurityInfo()
       meta_type='ECHO_collection'
       default_catalog='resourceCatalog'
           
     self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])      rootMetaTypes = ['ECHO_root', 'ECHO_main', 'ECHO_nav']
           
   #    viewClassificationList=viewClassificationListMaster
       displayTypes=displayTypes
   
       path="/mpiwg/online/permanent/shipbuilding"
                   
         if template=="yes":      def getSection(self, crumbs=None):
         pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')          """returns the current section name"""
           # use breadcrumbs if available
           if crumbs is not None and len(crumbs) > 0:
               return crumbs[0][2].getId()
       
           p = self
           sec = None
           # descend parents to the root (and remember the last id)
           while p is not None and p.meta_type not in self.rootMetaTypes:
               sec = p.getId()
               p = aq_parent(p.context)
        
           return sec
       
       def getSubSection(self, crumbs=None):
           """returns the current subsection name"""
           # use breadcrumbs if available
           if crumbs is not None and len(crumbs) > 1:
               return crumbs[1][2].getId()
       
           p = self
           sec = None
           subsec = None
           # descend parents to the root (and remember the last id)
           while p is not None and p.meta_type not in self.rootMetaTypes:
               subsec = sec
               sec = p.getId()
               p = aq_parent(p.context)
             
           return subsec
       
       
       def getCrumb(self):
           """returns breadcrumb for this object"""
           return ECHO_helpers.getCrumb(self)
   
       def getHierCrumbs(self):
           """returns a list of hierarchical breadcrumbs from self to the ECHO_root"""
           return ECHO_helpers.getHierCrumbs(self)
   
       
       def exportImportObjects_html(self,RESPONSE):
           """ImportObject"""
           pt=zptFile(self, 'zpt/exportImportObjects.zpt')
           pt.content_type="text/html"
         return pt()          return pt()
   
       def importObjects_html(self,RESPONSE):
           """ImportObject"""
           pt=zptFile(self, 'zpt/importObjects.zpt')
           pt.content_type="text/html"
           return pt()
           
       def importObjects(self,zfile,RESPONSE=None,REQUEST=None):
           """import object from file"""
   
               zf=zipfile.ZipFile(zfile,"r")
               tmpdir=tempfile.mkdtemp() # create tempdir
     def ECHO_getMD(self,item):          ret=None
         """Ausgabe der MD"""          
         return getattr(self,item)          for name in zf.namelist():
                  ds,fn=tempfile.mkstemp()
     def checkRDF(self,path):                 tf=file(fn,"w")
         """check if pdf in the path"""                 x=zf.read(name)
                  tf.write(x)
                  tf.close()
         try:          try:
             for fileName in os.listdir(path):                     self._importObjectFromFile(fn,set_owner=1)
                 if os.path.splitext(fileName)[1]==".pdf":  
                     return os.path.join(path,fileName)  
             return None  
         except:          except:
             return None                     if not ret:
                                  ret=""
                              ret+="Cannot import: %s (Already existing?)<br>"%name
     def index_html(self):             os.close(ds)
         """standard page"""                 os.remove(fn)
         pdf=self.checkRDF(self.link)  
     if pdf:  
         fh=file(pdf,'r').read()  
         self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')  
         self.REQUEST.RESPONSE.write(fh)  
         self.REQUEST.RESPONSE.close()  
         return   
         return self.REQUEST.RESPONSE.redirect(self.link)  
   
     def startpage_html(self):  
         """prints out a startpage for a resource for use e.g. in the BVE"""  
   
         # suche ob startpage.html in dem Ordner vorhanden ist, dann wir diese angezeigt  
   
         sp=self.ZopeFind(self,obj_ids=['startpage.html'])  
   
         if sp:          zf.close()
             return sp[1]()  
   
             #pruefen ob irgendwo ein template          if ret:
         if hasattr(self,'startpage_index_template'):               return """<html><body>%s</body></html>"""%ret
             return self.startpage_index_template()          if RESPONSE:
               RESPONSE.redirect(self.absolute_url())
   
         #generisches template ausgeben      def exportObjects_html(self,RESPONSE):
           """Export objects"""
                   
         pt=zptFile(self, 'zpt/ECHO_startpage_index_template_standard.zpt')          pt=zptFile(self, 'zpt/exportObjects.zpt')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
   
     def toc_html(self):      def exportObjects(self,ids,RESPONSE=None):
           """export objects with type id"""
           if not (type(ids) is ListType):
               ids=[ids]
                   
         sp=self.ZopeFind(self,obj_ids=['toc.html'])          tmpdir=tempfile.mkdtemp() # create tempdir
           objs=self.ZopeFind(self,obj_ids=ids)
           tmpfile=tempfile.mkstemp()[1]
                           
         if sp:          zf=zipfile.ZipFile(tmpfile,"w")
             return sp[0][1]()          for obj in objs:
   
               f = os.path.join(tmpdir, '%s.zexp' %obj[0])
               #print E.absolute_url()
   
     security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination              obj[1]._p_jar.exportFile(obj[1]._p_oid, f)
   
     def generate_label(self):              zf.write(f,obj[0])
         """Erzeugt_standard_Label aus Template"""  
         pt=getattr(self,"label_template_"+self.contentType.lower())  
   
     self.label=pt()[0:]  
         return pt()  
   
     security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination  
   
     def generate_title(self,RESPONSE=None):  
         """Erzeugt_standard_Label aus Template"""  
         pt=getattr(self,"label_template_"+self.contentType.lower())  
   
     self.title=pt()[0:]  
       
         return pt()  
   
 Globals.InitializeClass(ECHO_resource)  
   
 def manage_addECHO_resourceForm(self):  
         """Form for adding a ressource"""  
         pt=zptFile(self, 'zpt/AddECHO_resourceForm.zpt')  
         return pt()  
   
   
   
 def manage_addECHO_resource(self,id,title,label,description,responsible,link,metalink,weight,copyrightType=None,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):  
     """addaresource"""  
   
     newObj=ECHO_resource(id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)  
   
     self._setObject(id,newObj)  
   
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
    
   
 class ECHO_externalLink(Folder,ECHO_basis):  
     """Link zu einer externen Ressource"""  
     security=ClassSecurityInfo()  
     meta_type='ECHO_externalLink'  
   
   
     def content_html(self):  
         """template fuer content"""  
         return ECHO_basis.content_html(self,'externalLink')  
       
     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):  
   
         self.id = id  
         """Festlegen der ID"""  
   
         self.credits=toList(credits)  
         self.label = label  
         self.link= link  
         self.title=title  
         self.weight=weight  
         self.description=description  
         self.contentType=contentType  
         self.responsible=responsible  
         coordsnew=[ string.split(x,",") for x in coords]  
         self.coords=coordsnew  
   
     def ECHO_externalLink_config(self):  
         """Main configuration"""  
   
         if not hasattr(self,'weight'):  
             self.weight=""  
         if not hasattr(self,'coords'):  
               
             self.coords=['']  
   
   
         pt=zptFile(self, 'zpt/ChangeECHO_externalLink.zpt')  
         return pt()  
       
   
     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):  
         """Aenderung der Properties"""  
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)  
   
         self.link=link  
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
               
               
     manage_options = Folder.manage_options+(  
         {'label':'Main Config','action':'ECHO_externalLink_config'},  
         )  
   
           
     def index_html(self):  
         """standard page"""  
           
         return self.REQUEST.RESPONSE.redirect(self.link)  
   
 def manage_addECHO_externalLinkForm(self):  
         """Form for external Links"""  
         pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')  
         return pt()  
   
   
 def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):  
     """Add an external Link"""  
   
     newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)  
   
     self._setObject(id,newObj)  
   
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
     
           zf.close()
           shutil.rmtree(tmpdir)
           if RESPONSE:
               RESPONSE.setHeader("Content-Type","application/octet-stream")
               len=os.stat(tmpfile)[6]
               RESPONSE.setHeader("Content-Length",len)
               RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"export.zip")
               fh=file(tmpfile)
               for x in fh.read():
                   RESPONSE.write(x)
               fh.close()
   
 class ECHO_link(ECHO_externalLink):      def getMDValueSimpleSearchField(self):
     """external_link"""            """returns value for simple search"""
             return " ".join([self.title,self.description])
                                
       def getTitleAndLabel(self):
           """gibt title und label zurueck"""
           return (getattr(self,'title',''),getattr(self,'label',''))
   
       def localizeObjects(self):
               """localize all objects"""
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_externalLink','ECHO_link','ECHO_mapText'])
   
               find=self.ZopeFind(self,obj_ids=('locale_en'))
               if not find:
                   self.manage_addECHO_locale("en",'','')
               for content in contents:
   
     meta_type="ECHO_link"                      if content[1].meta_type in ['ECHO_link','ECHO_externalLink']:
           
                               find=content[1].ZopeFind(content[1],obj_metatypes=('ECHO_mapText'))
                               if find:
                                       root=find[0][1]
   
     def content_html(self):                                      locale=find[0][1].ZopeFind(find[0][1],obj_ids=('locale_en'))
         """template fuer link"""  
         if hasattr(self,"link_template"):  
             return ECHO_basis.content_html(self,'link')  
         else:          else:
             return ECHO_basis.content_html(self,'collection')                                      root=None
                       else:
                               root=content[1]
                               locale=content[1].ZopeFind(content[1],obj_ids=('locale_en'))
                       if root and not locale:
                               root.manage_addECHO_locale("en",'','')
           
 def manage_addECHO_linkForm(self):              pt=zptFile(self, 'zpt/localizeObjects.zpt')
         """Form for external Links"""  
         pt=zptFile(self, 'zpt/AddECHO_linkForm.zpt')  
         return pt()          return pt()
   
   
 def manage_addECHO_link(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):      def localize(self,REQUEST,RESPONSE):
     """Add an external Link"""              """localize"""
               for key in REQUEST.form.keys():
                       splitted=key.split("!")
   
     newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)                      if splitted[0]=="" or splitted[0]=="en" or splitted[0]=="title" or splitted[0]=="label":
                               if splitted[0]=="en":
                                       setattr(self.locale_en,splitted[1],REQUEST.form[key])
                               else:
                                       setattr(self,splitted[0],REQUEST.form[key])
                       else:
                               obj=getattr(self,splitted[0])
   
     self._setObject(id,newObj)                              if obj.meta_type=="ECHO_mapText":
                                       if splitted[1]=="en":
                                               obj.locale_en.pt_edit(REQUEST.form[key],obj.locale_en.content_type)
                                       else:
                                               obj.pt_edit(REQUEST.form[key],obj.content_type)
                               else:
                                       text=obj.ZopeFind(obj,obj_metatypes=['ECHO_mapText'])
                                       if splitted[1]=="en":
   
                                               text[0][1].locale_en.pt_edit(REQUEST.form[key],text[0][1].locale_en.content_type)
                                       else:
                                               text[0][1].pt_edit(REQUEST.form[key],text[0][1].content_type)
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
   
 class ECHO_collection(Folder, Persistent, Implicit, Cacheable,ECHO_basis):  
     """ECHO Collection"""  
   
     security=ClassSecurityInfo()  
     meta_type='ECHO_collection'  
 #    viewClassificationList=viewClassificationListMaster  
     displayTypes=displayTypes  
   
     path="/mpiwg/online/permanent/shipbuilding"  
   
     def getRDF(self,urn=None):      def getRDF(self,urn=None):
         """rdf of the collection"""          """rdf of the collection"""
                   
Line 1441  class ECHO_collection(Folder, Persistent Line 900  class ECHO_collection(Folder, Persistent
         if not urn:          if not urn:
             urn=self.absolute_url()              urn=self.absolute_url()
                           
         li="""<RDF:li RDF:resource="%s" />\n"""              li="""<rdf:li rdf:resource="%s" />\n"""
   
                   
         for content in contents:          for content in contents:
           try:
             ret+=content[1].getRDF()+"\n"              ret+=content[1].getRDF()+"\n"
                               except:
         ret+="""<RDF:Seq RDF:about="%s">\n"""%urn              logging.error("getrdf: "+repr(content[1].getRDF()))
               try:
                   ret+=self.unicodify(content[1].getRDF())+"\n"
               except:
               logging.error("--still cannot do it")
                   ret+=repr(content[1].getRDF())+"\n"
               ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
         for content in contents:          for content in contents:
             nurn=content[1].absolute_url()              nurn=content[1].absolute_url()
             ret+=li%nurn              ret+=li%nurn
         return ret+"</RDF:Seq>"              return ret+"</rdf:Seq>"
                   
   
           
Line 1478  class ECHO_collection(Folder, Persistent Line 944  class ECHO_collection(Folder, Persistent
         pt=zptFile(self, 'zpt/changeMetaDataLinkForm')          pt=zptFile(self, 'zpt/changeMetaDataLinkForm')
         pt.content_type="text/html"          pt.content_type="text/html"
         return pt()          return pt()
               
       def changeAccessRightsCollectionForm(self,preselect=None):
           """change access rights of all resources in this collection"""
   
           pt=zptFile(self, 'zpt/changeAccessRightsCollectionForm')
           pt.content_type="text/html"
           return pt(preselect=preselect)
           
           
     def changeAccessRightsCollection(self):      def changeAccessRightsCollection(self):
         """change"""          """change"""
         ret=""          ret=""
Line 1486  class ECHO_collection(Folder, Persistent Line 961  class ECHO_collection(Folder, Persistent
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])          resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
         for resource in resources:          for resource in resources:
                         
             try:                      if argv.has_key(resource[1].getId()+'_xml'):
                 ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"                              ret+=resource[1].getId()+"   "+argv[resource[1].getId()+'_xml']+"</br>"
                 resource[1].changeAccessRightMD(argv[resource[1].getId()])                              resource[1].setAccessRightXML(argv[resource[1].getId()+'_xml'])
             except:                              resource[1].accessRight=argv[resource[1].getId()+'_xml']
                 pass                      elif argv.has_key(resource[1].getId()+'_echo'):
                               ret+="only local:"+resource[1].getId()+"   "+argv[resource[1].getId()+'_echo']+"</br>"
                               resource[1].accessRight=argv[resource[1].getId()+'_echo']
                       else:
                               ret+="ERROR:" +resource[0]
         return ret          return ret
   
     def changeMetaDataLinkInCollection(self):      def changeMetaDataLinkInCollection(self):
Line 1528  class ECHO_collection(Folder, Persistent Line 1007  class ECHO_collection(Folder, Persistent
         ret=""          ret=""
         argv=self.REQUEST.form          argv=self.REQUEST.form
                   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         for resource in resources:          for resource in resources:
                         
             try:              try:
Line 1543  class ECHO_collection(Folder, Persistent Line 1022  class ECHO_collection(Folder, Persistent
         ret=""          ret=""
         argv=self.REQUEST.form          argv=self.REQUEST.form
                   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
         for resource in resources:          for resource in resources:
                         
             try:              try:
Line 1553  class ECHO_collection(Folder, Persistent Line 1032  class ECHO_collection(Folder, Persistent
                 pass                  pass
         return ret          return ret
                   
     def updateCollection(self,RESPONSE=None):      def changeLabelsInCollection(self):
               """change all lables of a collection"""
               ret=""
               argv=self.REQUEST.form
               
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_pageTemplate','ECHO_movie','ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])
               for resource in resources:
                      
                       try:
                               ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"
                               resource[1].label=argv[resource[1].getId()][0:]
                       except:
                               pass
               return ret
          
       def importCollection(self,path=None,viewerUrl=None,metaDataUrl=None,replacePathPermanent=None,replacePathExperimental=None,RESPONSE=None):
         """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""          """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
         files=os.listdir(self.path)          
           if path is None:
                   pt=zptFile(self, 'zpt/importCollection.zpt')
                   return pt()
   
           files=os.listdir(path)
     ret=""      ret=""
         for fileName in files:          for fileName in files:
                           
             if fileName:              if fileName:
                   
         tempPath=re.sub("/mpiwg/online","",self.path)                  if (replacePathExperimental and replacePathExperimental!=''):
         link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"                      path=re.sub(replacePathExperimental,"/mpiwg/online/experimental",path)
                      
                   if (replacePathPermanent and replacePathPermanent!=''):
                       path=re.sub(replacePathPermanent,"/mpiwg/online/permanent",path)
                   
         metalink=self.path+"/"+fileName+"/index.meta"                  link=viewerUrl%(path+"/"+fileName+"/pageimg")
                   
                   metalink=metaDataUrl+"/"+path+"/"+fileName+"/index.meta"
                 try:                  try:
   
             #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"              #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"
                           
             newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'generated','book','','','','','','')                          newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'','book','','','','','','')
             self._setObject(fileName,newObj)              self._setObject(fileName,newObj)
                                   
             genObj=getattr(self,fileName)              genObj=getattr(self,fileName)
Line 1584  class ECHO_collection(Folder, Persistent Line 1088  class ECHO_collection(Folder, Persistent
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def updateCollectionMD(self,RESPONSE=None):  
         """updateMD"""  
         files=os.listdir(self.path)  
         for fileName in files:  
             if fileName:  
                 genObj=getattr(self,fileName)  
                 genObj.copyIndex_meta2echo_resource()  
                 genObj.generate_title()  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
       def changeViewerForm(self):
   
     def changeViewerTemplateSetsForm(self):  
         """change the viewer template set"""          """change the viewer template set"""
         pt=zptFile(self, 'zpt/changeViewerTemplateSet')              pt=zptFile(self, 'zpt/changeECHOViewer')
             return pt()              return pt()
   
     def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):  
         """Get the ViewerTemplateSet title for configuration"""  
         ret=[]  
           
         try:  
             viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.  
               
             for viewerTemplateSet in viewerTemplateSets:  
                 ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))  
   
             return ret  
               
         except:  
             return [('no ViewerTemplateSetfolders','')]  
   
     def getTextToolsField(self,name,default=''):      def getTextToolsField(self,name,default=''):
         """Lese viewerTemplateSet der Collection not implemented yet!"""              """Lese text tool field  der Collection not implemented yet!"""
                   
         return default          return default
   
                           
     def isSelectedViewerTemplateSet(self,obj,id):  
         """is ausgewaehlt"""  
           
         if self.REQUEST['viewerTemplateSet']==id:  
             return 1  
         else:  
             return None  
   
     def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):      def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):
         """change the templates"""          """changes all ressources to the newViewer"""
   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)          resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
           if RESPONSE is not None:
                       RESPONSE.write("<html><body>")
   
         for resource in resources:          for resource in resources:
   
             resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)              done,msg=resource[1].changeViewer(newViewer)
               if done:
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')                      RESPONSE.write("<p>OK: %s"%resource[0])
               else:
                   if RESPONSE is not None:
     def setStartpageFolderForm(self):                      RESPONSE.write("<p><a href='%s'>ERROR: %s (%s)</a>"%(resource[1].absolute_url()+'/ECHO_resource_config_main',resource[0],msg))
         """Form for changing the startpage"""  
   
                   
         pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPageFolder.zpt')  
             pt.content_type="text/html"  
             return pt()  
           
     def setStartpageFolder(self,startpage=None,RESPONSE=None):  
         """change the templates"""  
   
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)          if RESPONSE is not None:
                       RESPONSE.write("<p>Done</p></body></html>")
         for resource in resources:  
   
             resource[1].setStartPage(startpage)  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def copyTitleToInfoXMLFolder(self,RESPONSE=None):      def copyTitleToInfoXMLFolder(self,RESPONSE=None):
         """copy title into the title field of info.xml          """copy title into the title field of info.xml
Line 1681  class ECHO_collection(Folder, Persistent Line 1141  class ECHO_collection(Folder, Persistent
             if ret and RESPONSE:              if ret and RESPONSE:
                 RESPONSE.write("ok: %s\n"%txt)                  RESPONSE.write("ok: %s\n"%txt)
                           
             #zLOG.LOG("ECHO (copyTitleToInfoXMLFolder)",zLOG.INFO,txt)                         #logger("ECHO (copyTitleToInfoXMLFolder)",logging.INFO,txt)   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.write("done!\n")              RESPONSE.write("done!\n")
             RESPONSE.close()              RESPONSE.close()
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     def copySearchFields(self,RESPONSE=None):      def copySearchFields(self,RESPONSE=None):
         """copys import metadatafields to the object"""              """copys < metadatafields to the object"""
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
         for resource in resources:          for resource in resources:
   
Line 1698  class ECHO_collection(Folder, Persistent Line 1158  class ECHO_collection(Folder, Persistent
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     def reloadMetaDataFromStorageWarning(self,RESPONSE=None):  
         """warning"""  
         pt=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=None)  
   
           
     def getPartnerCopyright(self,name,sonst="generic"):      def getPartnerCopyright(self,name,sonst="generic"):
Line 1729  class ECHO_collection(Folder, Persistent Line 1179  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
Line 1757  class ECHO_collection(Folder, Persistent Line 1209  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 1772  class ECHO_collection(Folder, Persistent Line 1226  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 1821  class ECHO_collection(Folder, Persistent Line 1308  class ECHO_collection(Folder, Persistent
     ret="""<?xml version="1.0" encoding="utf-8" ?>"""      ret="""<?xml version="1.0" encoding="utf-8" ?>"""
         return ret+"<collection>"+getCollection(self,pwstr=pwstr)+"</collection>"          return ret+"<collection>"+getCollection(self,pwstr=pwstr)+"</collection>"
           
     def createAllJSAreas(self):      def createAllJSAreas(self,mapColTypes=None):
         """create area calls for JavaScript"""          """create area calls for JavaScript"""
         areas = self.getAllMapAreas()          areas = self.getAllMapAreas(mapColTypes=mapColTypes)
     return self.createJSAreas(areas)      return self.createJSAreas(areas)
   
       
       emptyPartner=ECHO_partner("", "","", "", "", "", "", "", "")
       
     security.declarePublic('getCreditObject')      security.declarePublic('getCreditObject')
     def getCreditObject(self,name):      def getCreditObject(self,name):
         """credit id to credititem"""          """credit id to credititem"""
         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 1868  class ECHO_collection(Folder, Persistent Line 1360  class ECHO_collection(Folder, Persistent
     return ECHO_rerenderLinksMD(self,obj,types)      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 1886  class ECHO_collection(Folder, Persistent Line 1378  class ECHO_collection(Folder, Persistent
         self.secondaryLinkTitle=secondaryLinkTitle          self.secondaryLinkTitle=secondaryLinkTitle
         self.secondaryLink=secondaryLink          self.secondaryLink=secondaryLink
     self.bgcolour=bgcolour      self.bgcolour=bgcolour
           self.isVisible=isVisible
                   
   
     manage_options = Folder.manage_options+ Cacheable.manage_options+(      manage_options = Folder.manage_options+ Cacheable.manage_options+(
         {'label':'Main Config','action':'ECHO_collection_config'},          {'label':'Main Config','action':'ECHO_collection_config'},
         {'label':'Change Labels','action':'changeLabels'},          {'label':'Change Labels','action':'changeLabels'},
         {'label':'Change Titles','action':'changeTitles'},          {'label':'Change Titles','action':'changeTitles'},
           {'label':'Localize','action':'localizeObjects'},
     {'label':'Change Weights','action':'changeWeights'},      {'label':'Change Weights','action':'changeWeights'},
         {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},          {'label':'Rerender Labels and Titles','action':'ECHO_rerenderLinksMDWarning'},
           {'label':'Export/Import Objects','action':'exportImportObjects_html'},
         {'label':'Graphic Coords','action':'ECHO_graphicEntry'},          {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
     {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},      {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
     {'label':'Set Startpage','action':'setStartpageFolderForm'},          {'label':'Change Image Viewer','action':'changeViewerForm'},
         {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},          {'label':'ImportCollection','action':'importCollection'},
     {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},          {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},
     {'label':'ImportCollection','action':'updateCollection'},  
     {'label':'Copy MD for indexing and search','action':'copySearchFields'},  
         )          )
   
           
Line 1927  class ECHO_collection(Folder, Persistent Line 1420  class ECHO_collection(Folder, Persistent
   
                   
     security.declarePublic('changeECHO_collection')           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):      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
Line 1936  class ECHO_collection(Folder, Persistent Line 1429  class ECHO_collection(Folder, Persistent
     self.bgcolour=bgcolour      self.bgcolour=bgcolour
         self.location=location          self.location=location
     self.isAlwaysClickable=isAlwaysClickable      self.isAlwaysClickable=isAlwaysClickable
           self.prefix=prefix[0:]
           self.suffix=suffix[0:]
           self.setIsVisible(isVisible)
                           
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)          setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
                   
Line 1955  class ECHO_collection(Folder, Persistent Line 1451  class ECHO_collection(Folder, Persistent
           
     def showOverview(self):      def showOverview(self):
         """overview"""          """overview"""
         if 'ECHO_overview.html' in self.__dict__.keys():          # use ECHO_overview.html template in this instance
             return getattr(self,'ECHO_overview.html')()          if 'ECHO_overview.html' in self:
               return self['ECHO_overview.html']()
           
           # use ECHO_overview_main template in path
           if hasattr(self, 'ECHO_overview_main'):
               return getattr(self, 'ECHO_overview_main')()
           
           # use template from Product
         pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')          pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')
         return pt()          return pt()
   
     security.declareProtected('View','index_html')  
           
       security.declareProtected('View','index_html')
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
         if self.ZCacheable_isCachingEnabled():          if self.ZCacheable_isCachingEnabled():
               
             result = self.ZCacheable_get()              result = self.ZCacheable_get()
             if result is not None:              if result is not None:
                 # Got a cached value.                  # Got a cached value.
                 return result                  return result
           
         if 'index.html' in self.__dict__.keys():          # old Zope 2.9 method
             ret=getattr(self,'index.html')()          #if 'index.html' in self.__dict__.keys():
           #    ret=getattr(self,'index.html')()
   
           # use Zope 2.12 IContainer for child access
           if 'index.html' in self:
               # use index.html template if it exists
               ret = self['index.html']()
                   
         elif 'overview' in self.__dict__.keys():          elif 'overview' in self:
               # use red-rectangle template when there's an 'overview'
             ret=self.showOverview()              ret=self.showOverview()
   
           # use getattr for acquisition
         elif hasattr(self,'collection_index_template'):          elif hasattr(self,'collection_index_template'):
               # use 'collection_index_template' in acquisition path
             ret=self.collection_index_template()                  ret=self.collection_index_template()    
               
         elif hasattr(self,'main_index_template'):          elif hasattr(self,'main_index_template'):
             ret=self.main_index_template()                  # use 'main_index_template' in acquisition path
               ret=self.main_index_template.__of__(self)(self.main_template)
               
         else:          else:
               # use template from Product
         pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')          pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
         pt.content_type="text/html"          pt.content_type="text/html"
         ret=pt.render()          ret=pt.render()
Line 1988  class ECHO_collection(Folder, Persistent Line 1504  class ECHO_collection(Folder, Persistent
     self.ZCacheable_set(ret)      self.ZCacheable_set(ret)
         return ret          return ret
   
       security.declarePublic('content_html')
     def content_html(self,**argv):      def content_html(self,**argv):
         """template fuer content"""          """template fuer content"""
     #print "NN",argv      #print "NN",argv
         return ECHO_basis.content_html(self,'collection')          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 2002  class ECHO_collection(Folder, Persistent Line 1525  class ECHO_collection(Folder, Persistent
   
     def area_img(self):      def area_img(self):
         """area image"""          """area image"""
     bt = BrowserCheck(self)          bt = browserType(self)
     if bt.isIE or bt.isN4:          if bt['isIE'] or bt['isN4']:
         return sendFile(self, 'images/red.gif', 'image/gif')          return sendFile(self, 'images/red.gif', 'image/gif')
     else:      else:
         return sendFile(self, 'images/reda.png', 'image/png')          return sendFile(self, 'images/reda.png', 'image/png')
Line 2028  class ECHO_collection(Folder, Persistent Line 1551  class ECHO_collection(Folder, Persistent
         """javascript"""          """javascript"""
         return sendFile(self, 'js/hl_add.js', 'text/plain')          return sendFile(self, 'js/hl_add.js', 'text/plain')
   
     def getAllMapAreas(self):      def getAllMapAreas(self,mapColTypes=None):
         """Give list of coordinates"""          """Give list of coordinates"""
         mapColTypes=['ECHO_collection','ECHO_resource']          if mapColTypes is None:
               mapColTypes=['ECHO_collection','ECHO_resource','ECHO_link','ECHO_externalLink']
               
         areas=[]          areas=[]
         for entry in self.getSubCols(self,subColTypes=mapColTypes):          for entry in self.getSubCols(subColTypes=mapColTypes):
             object=entry              object=entry
         areas.extend(object.getMapAreas())          areas.extend(object.getMapAreas())
         return areas          return areas
Line 2051  class ECHO_collection(Folder, Persistent Line 1576  class ECHO_collection(Folder, Persistent
   
     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):
Line 2059  def manage_addECHO_collectionForm(self): Line 1590  def manage_addECHO_collectionForm(self):
         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 2093  class ECHO_group(ECHO_collection): Line 1624  class ECHO_group(ECHO_collection):
                   
         if not urn:          if not urn:
             urn=self.absolute_url()              urn=self.absolute_url()
         li="""<RDF:li RDF:resource="%s" />\n"""              li="""<rdf:li rdf:resource="%s" />\n"""
                   
                   
         for content in contents:          for content in contents:
             ret+=content[1].getRDF()+"\n"                      ret+=self.unicodify(content[1].getRDF())+"\n"
                           
         ret+="""<RDF:Seq RDF:about="%s">\n"""%urn              ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
         for content in contents:          for content in contents:
             nurn=content[1].absolute_url()              nurn=content[1].absolute_url()
             ret+=li%nurn              ret+=li%nurn
         return ret+"</RDF:Seq>"              return ret+"</rdf:Seq>"
                   
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
Line 2167  class ECHO_group(ECHO_collection): Line 1698  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 ECHO_basis.content_html(self,'group')          return ECHO_basis.content_html(self,'group')
Line 2286  class ECHO_userFolder(UserFolder): Line 1818  class ECHO_userFolder(UserFolder):
             return 1              return 1
         return 0          return 0
   
 Globals.default__class_init__(ECHO_userFolder)  # ROC: problem with 2.12
   #Globals.default__class_init__(ECHO_userFolder)
   
   
   
Line 2341  def createNode(self,descrs,node): Line 1874  def createNode(self,descrs,node):
     return "XX"      return "XX"
   
   
 class ECHO_root(Folder,Persistent,Implicit):  
     """ECHO Root Folder"""  
   
     security=ClassSecurityInfo()  
       
     meta_type="ECHO_root"  
   
     def getContentOverviewTemplate(self):  
     """produces overview template with macro"""  
     pt = zptObjectOrFile(self, 'content_overview_template')  
     return pt  
   
     ###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 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()  
     getSubCols = ECHO_helpers.getSubCols  
   
     manage_options=Folder.manage_options+(  
         {'label':'Main Config','action':'ECHO_copyright_configForm'},  
         {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},  
         {'label':'Change Weights','action':'changeWeights'},  
         {'label':'Generate from RDF','action':'generateFromRDFForm'},  
   
 )  
   
       
   
     def 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):  
         """get field tag for index-meta-generation"""  
         if not content or content=="":  
             return ""  
         ret="<%s>"%tag  
         #ret+=urllib.quote(content)  
         ret+=content  
   
         ret+="</%s>"%tag  
         return ret  
   
     def getValueFromClass(self,field,found):  
         """retattribute falss existing"""  
         try:  
               
             return getattr(found,field).decode('ascii','ignore')  
         except:  
             return ""  
       
     def getImageTag(self):  
         """needed by main_template"""  
         return ""  
     secondaryLink="" #needed by main_template  
     secondaryLinkTitle="" #needed by main_template  
       
     def getBgcolour(self):  
     """hack"""  
     return "#dddddd"  
   
     def contentTypeSelector_HTML(self,selected=None):  
         """give type selector"""  
         if not selected:  
             retStr="<option selected>\n"  
         else:  
             retStr="<option>\n"  
               
         try: # erste version contentTypes exists  
             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):  
                 if selected and (contentType[0]==selected):  
                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])  
                 else:                  
                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])  
         except:  
         try:  
             for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):  
                 if selected and (contentType[0]==selected):  
                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])  
                 else:                  
                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])  
         except:  
             """nothing"""  
                   
     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 renderingTypeSelector_HTML(self,selected=None):  
          """give type selector"""  
      if not selected:  
          retStr="<option selected>\n"  
      else:  
          retStr="<option>\n"  
            
      try: # erste version renderingTypes exists  
          for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):  
              if selected and (renderingType[0]==selected):  
                  retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])  
              else:                  
                  retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])  
      except:  
          """nothing"""  
      return retStr  
   
   
     def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):  
          """give type selector"""  
   
      if not first:  
          if not selected:  
              retStr="<option selected>\n"  
          else:  
              retStr="<option>\n"  
      else:  
          if not selected:  
              retStr="""<option selected value="%s">%s\n"""%first  
          else:  
              retStr="""<option value="%s">%s\n"""%first  
   
        
      try: # erste version copyrightTypes exists  
          for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):  
              if selected and (copyrightType[0]==selected):  
                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
              else:                  
                  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:  
          """nothing"""  
            
      return retStr  
   
     def partnerSelector_HTML(self,selected=None):  
          """give type selector"""  
      if not selected:  
          retStr="<option selected>\n"  
      else:  
          retStr="<option>\n"  
            
      try: # erste version copyrightTypes exists  
          for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):  
              if selected and (copyrightType[0]==selected):  
                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
              else:                  
                  retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
      except:  
          """nothing"""  
      return retStr  
    
     mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version ueber echoroot??  
   
     def mediaTypeSelector_HTML(self,selected=None):  
          """give type selector"""  
      if not selected:  
          retStr="<option selected>\n"  
      else:  
          retStr="<option>\n"  
        
      try: # erste version mediatypesTypes exists  
          for mediaType in self.mediaTypes:  
              if selected and (mediaType in selected):  
                  retStr+="""<option selected value="%s">%s\n"""%(mediaType,mediaType)  
              else:                  
                  retStr+="""<option value="%s">%s\n"""%(mediaType,mediaType)  
      except:  
          """nothing"""  
      return retStr  
   
               
     def patchContentType(self,obj=None):  
         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""  
       
   
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])  
   
         for entry in entries:  
                 setattr(entry[1],'contentType',entry[1].content_type)  
                 #entry[1].contentType == entry[1].content_type  
   
                 if entry[1].meta_type == 'ECHO_collection':  
                     entry[1].patchContentType(entry[1])      
   
                   
         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):  
         """setze viewClassification heuristisch"""  
   
     def checkIfArrow(obj):  
         if hasattr(obj,'coords'):  
             for coordtemp in obj.coords:  
   
                 if (len(coordtemp)>4) and not (coordtemp[4]==''):  
                     return 4  
             return None  
         return None  
       
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])  
   
         for entry in entries:  
           
         if checkIfArrow(entry[1]):  
             setattr(entry[1],'viewClassification','view point')  
         else:  
             setattr(entry[1],'viewClassification','area')  
   
                 #entry[1].contentType == entry[1].content_type  
   
                 if entry[1].meta_type in ['ECHO_collection','ECHO_group']:  
                     entry[1].patchViewClassification(entry[1])      
   
                   
         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):  
         """change links (:86 faellt weg)"""  
   
         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].link=re.sub('\:86','',entry[1].link)  
   
                 else:  
                       
                     entry[1].ECHO_newViewerLink(entry[1])  
                   
         return "Rerenderd all links to resources in: "+self.title  
   
     def __init__(self,id,title):  
         """init"""  
         self.id = id  
         self.title=title  
   
     def deleteSpace(self,str):  
         """delete space at the end of a line"""  
         if str[len(str)-1]==" ":  
             return str[0:len(str)-1]  
         else:  
             return str  
           
       
   
     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt  
   
     def formatAscii(self,str,url=None):  
         """ersetze ascii umbrueche durch <br>"""  
         #url=None  
         if url:  
               
             retStr=""  
             words=str.split("\n")  
               
             for word in words:  
                 strUrl=url%word  
   
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)  
             str=retStr  
         if str:  
             return re.sub(r"[\n]","<br/>",str)  
         else:  
             return ""  
           
     def link2html(self,str):  
         """link2html fuer VLP muss hier noch raus"""  
         if str:  
   
             str=re.sub("\&","&amp;",str)  
             dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>")  
             links=dom.getElementsByTagName("link")  
               
   
             for link in links:  
                 link.tagName="a"  
         ref=link.getAttribute("ref")  
         pn=link.getAttribute("page")  
               
                 if self.checkRef(ref):  
             if pn:  
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref+"&p="+pn)  
             else:  
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref)  
   
   
             newxml=dom.toxml('utf-8')  
         
         retStr=regexpTXT.search(newxml)  
   
         return retStr.group(1)  
   
                  
         return ""  
   
     def xml2html(self,str,quote="yes"):  
         """link2html fuer VLP muss hier noch raus"""  
   
         if str:  
             if quote=="yes2":  
                 str=re.sub("\&","&amp;",str)  
             #dom=xml.dom.minidom.parseString(str)  
         dom = NonvalidatingReader.parseString(str,"http://www.mpiwg-berlin.mpg.de/")  
             #links=dom.getElementsByTagName("link")  
             links=Ft.Xml.XPath.Evaluate(".//link", contextNode=dom)  
             for link in links:  
                 #link.tagName="a"  
       
                 ref=link.getAttributeNS(EMPTY_NAMESPACE,"ref")  
         pn=link.getAttributeNS(EMPTY_NAMESPACE,"page")  
   
         cns=link.childNodes[0:]  
           
         newLink=dom.createElementNS(EMPTY_NAMESPACE,"a")  
         for x in cns:  
             newLink.appendChild(x)  
           
               
           
         link.parentNode.replaceChild(newLink,link)  
                 if self.checkRef(ref):  
             if pn:  
                 newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)  
             else:  
                 newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)  
   
             #str= dom.toxml('utf-8')  
         buf = cStringIO.StringIO()  
         PrettyPrint(dom, stream=buf, encoding='UTF-8')  
         str = buf.getvalue()  
         buf.close()  
         #str=PrettyPrint(dom.documentElement,encoding='UTF-8')  
         #print link.toxml('utf-8')  
         #print type(str)  
         retStr=regexpPage.search(str)  
         try: # hack warum fehtl manchmal page??  
             return retStr.group(1)  
         except:  
             return str  
         return ""  
   
     def checkRef(self,ref):  
         if ref[0:3]=='lit':  
             if len(self.library_data({ 'id':ref}))>0:  
                 return 1  
         try:  
             if ref[0:7]=="tec_cat":  
                 return 1  
         except:  
             """nothing"""  
               
         dbs={'vl_technology':'','vl_people':'','vl_sites':''}  
         res=None  
         for db in dbs.keys():  
             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))  
         return res  
                                       
     #Ende Methode fuer vlp  
   
     def PgQuoteString(self,string):  
         """Quote string"""  
   
         return libpq.PgQuoteString(string)  
           
     def getPartners(self):  
         """Get list of Partners. Presently only from a subfolder partners"""  
     if hasattr(self,'partners'):              
         return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]  
     else:  
         return []  
     
     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):  
         """partner liste als xml"""   
         partners=self.getPartners()  
         ret="""<?xml version="1.0" encoding="utf-8" ?>  
     <partners>"""  
           
     for partner in partners:  
             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)  
   
         return ret+"\n</partners>"  
       
     def getCollectionTree(self):  
         """get the collection tree (list of triples (parent,child, depth)"""  
   
         def getCollection(object,depth=0):  
             depth+=1  
             collections=[]  
             for entry in object.__dict__.keys():  
                 element=getattr(object,entry)  
                 try:  
                     if element.meta_type=="ECHO_collection":  
                         collections.append((object,element,depth))  
                         collections+=getCollection(element,depth)  
                 except:  
                     """nothing"""  
             return collections  
           
   
         return getCollection(self)  
       
     def getCollectionTreeIds(self):  
         """Show the IDs of the Tree"""  
         ret=[]  
         for collection in self.getCollectionTree():  
             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))  
         return ret  
   
     def getResourcesHTML(self,viewerType=None,filter=None):  
         """gebe all ressourcen aus"""  
   
         def sortHTML(x,y):  
             return cmp(x[1].title,y[1].title)  
           
         ret="""<html><body><h2>Resources in ECHO</h3>"""  
           
         resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)  
         ret+="""<h3>Found %i resources</h3>"""%len(resources)  
         resources.sort(sortHTML)  
         for resource in resources:  
             echo_url=resource[1].absolute_url()  
               
             if hasattr(resource[1],'title'):  
                 title=resource[1].title  
             else:  
                 title="None"  
             if filter:  
                 if re.search(filter,title):  
                     ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)  
             else:  
                 ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)  
   
         ret +="""\n</body></html>"""  
           
         #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")  
         #self.REQUEST.RESPONSE.write(ret)  
             return ret  
       
     def getResourcesXML(self,viewerType=None,filter=None):  
         """gebe all ressourcen aus"""  
         ret="""<?xml version="1.0" ?>  
                  <index>"""  
         for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
   
             echo_url=resource[1].absolute_url()  
             if hasattr(resource[1],'link'):  
                 viewer_url=resource[1].link  
             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:  
                 ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_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):  
         """gebe all ressourcen aus"""  
         ret="""<?xml version="1.0" ?>  
                  <index>"""  
         for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
   
             echo_url=resource[1].absolute_url()  
             if resource[1].getFullTextXML(noredirect="yes"):  
                 if hasattr(resource[1],'link'):  
                     viewer_url=echo_url+"/getFullTextXML"  
                 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:  
                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
         ret +="""\n</index>"""  
           
           
         self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
         self.REQUEST.RESPONSE.write(ret)  
   
   
     def getMetaDatasXML(self,viewerType=None,filter=None):  
         """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" ?>  
                  <index>"""  
         for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
   
             echo_url=resource[1].absolute_url()  
             if fix_host:  
                 #print "replacing ", http_host, " by ", fix_host  
                 echo_url = string.replace(echo_url, http_host, fix_host, 1)  
               
             if hasattr(resource[1],'link'):  
                 meta_url=echo_url+"/getMetaDataXML"  
             else:  
                 meta_url="NO_URL"  
                   
             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.write(ret)  
   
           
     def findPartners(self):   
         """find all partners in partners"""  
         par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')  
         return par  
           
     def getPartnerFromID(self):  
         """find partner form ID return object"""  
         pa=self.REQUEST['partner']  
         par=self.ZopeFind(self.partners, obj_ids=[pa])  
         return par  
           
     def getPartnerFromIDParameter(self, id):  
         """ find partners from ID"""  
         par=self.ZopeFind(self.partners, obj_ids=[id])  
         return par  
           
     def getInstitutionFromID(self,id):  
         """ find institution from id """  
         inst=self.ZopeFind(self.institutions, obj_ids=[id])  
         return inst  
   
           
 def manage_addECHO_root(self,id,title,RESPONSE=None):  
     """Add an ECHO_root"""  
     self._setObject(id,ECHO_root(id,title))  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
 def manage_addECHO_rootForm(self):  
         """Nothing yet"""  
         pt=zptFile(self, 'zpt/AddECHO_root.zpt')  
         return pt()  
   
 class ECHO_copyrightType(Folder,ECHO_basis):  class ECHO_copyrightType(Folder,ECHO_basis):
     """copyright typ"""      """copyright typ"""
Line 3205  def manage_addECHO_copyrightType(self,id Line 1924  def manage_addECHO_copyrightType(self,id
     
   
     
 class ECHO_partner(Image,Persistent,ECHO_basis):  
     """ECHO Partner"""  
   
     meta_type="ECHO_partner"  
   
     def __init__(self, id, title,url, file, copyrightType, person, email, country, color, content_type='', precondition=''):  
         self.__name__=id  
         self.title=title  
         self.url=url  
         self.person=person  
         self.email=email  
         self.country=country  
         self.color=color  
         self.precondition=precondition  
         self.copyrightType=copyrightType  
         data, size = self._read_data(file)  
         content_type=self._get_content_type(file, data, id, content_type)  
         self.update_data(data, content_type, size)  
   
     manage_options = Image.manage_options+(  
         {'label':'Partner Information','action':'ECHO_partner_config'},  
         )  
   
       
     def changeECHO_partner(self,url,copyrightType,person, email, country, color, RESPONSE=None):  
         """Change main information"""  
         self.url=url  
         self.person=person  
         self.email=email  
         self.country=country  
         self.color=color  
         self.copyrightType=copyrightType  
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
               
               
   
     def ECHO_partner_config(self):  
         """Main configuration"""  
         if not hasattr(self,'url'):  
             self.url=""  
         pt=zptFile(self, 'zpt/ChangeECHO_partner.zpt')  
         return pt()  
   
           
 manage_addECHO_partnerForm=DTMLFile('dtml/ECHO_partnerAdd',globals(),  
                              Kind='ECHO_partner',kind='ECHO_partner')  
   
   
   
 def manage_addECHO_partner(self, id, url, person, email, country, color, file=None, copyrightType='', title='', precondition='', content_type='',  
                     REQUEST=None):  
     """  
     Add a new ECHO_partner object.  
   
     Creates a new ECHO_partner object 'id' with the contents of 'file'.  
     Based on Image.manage_addImage  
     """  
   
     id=str(id)  
     title=str(title)  
     content_type=str(content_type)  
     precondition=str(precondition)  
   
     id, title = OFS.Image.cookId(id, title, file)  
   
     self=self.this()  
   
     # First, we create the image without data:  
     self._setObject(id, ECHO_partner(id,title,url,'',copyrightType, person, email, country, color, content_type, precondition))  
   
     # Now we "upload" the data.  By doing this in two steps, we  
     # can use a database trick to make the upload more efficient.  
     if file:  
         self._getOb(id).manage_upload(file)  
     if content_type:  
         self._getOb(id).content_type=content_type  
   
     if REQUEST is not None:  
         try:    url=self.DestinationURL()  
         except: url=REQUEST['URL1']  
         REQUEST.RESPONSE.redirect('%s/manage_main' % url)  
     return id  
   
 class ECHO_linkList(ZopePageTemplate,ECHO_basis):  class ECHO_linkList(ZopePageTemplate,ECHO_basis):
     """LinkList Objekt"""      """LinkList Objekt"""
Line 3325  class ECHO_linkList(ZopePageTemplate,ECH Line 1961  class ECHO_linkList(ZopePageTemplate,ECH
     def getcontentType(self):      def getcontentType(self):
         """get contentType"""          """get contentType"""
         if hasattr(self,'contentType'):          if hasattr(self,'contentType'):
             return self.contentType              return normalizeCt(self.contentType)
         else:          else:
             return 0              return 0
   
Line 3336  class ECHO_linkList(ZopePageTemplate,ECH Line 1972  class ECHO_linkList(ZopePageTemplate,ECH
          self.ZBindings_edit(self._default_bindings)           self.ZBindings_edit(self._default_bindings)
          if text is None:           if text is None:
              text = ''               text = ''
            if content_type is None:
                content_type = self.content_type
          self.pt_edit(text, contentType)           self.pt_edit(text, contentType)
   
   
Line 3436  def manage_addECHO_support(self, id,inst Line 2074  def manage_addECHO_support(self, id,inst
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                   
   # ECHO - owner of original
   class ECHO_ownerOriginal(Folder,ECHO_basis):
           """besitzer des originals"""
           meta_type="ECHO_ownerOriginal"
           security=ClassSecurityInfo()
           
           
           def __init__(self,id,institutions=None):
                   """init"""
                   self.id=id
                   self.title=''
                   self.institutions=toList(institutions)
   
           security.declarePublic('getOwner')
           def getOwner(self):
                   """return institutions"""
                   if self.institutions:
                           return self.institutions
                   else:
                           return []
                   
           manage_options = Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_ownerOriginal_configForm'},
                   )
   
           def ECHO_ownerOriginal_configForm(self):
                   """change form"""
                   pt=zptFile(self, 'zpt/ChangeECHO_ownerOriginal')
                   pt.content_type="text/html"
                   return pt()
   
           def ECHO_ownerOriginal_config(self,institutions=None,RESPONSE=None):
                   """change"""
                   self.institutions=toList(institutions)
   
                   if RESPONSE is not None:
                           RESPONSE.redirect('manage_main')
   
                   
   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):  class ECHO_institution(Image,Persistent,ECHO_basis):
     """ECHO Institution"""      """ECHO Institution"""
Line 3556  def repairCoords(self): Line 2307  def repairCoords(self):
             col.addMapArea(area)              col.addMapArea(area)
     msg += "\nDone!"      msg += "\nDone!"
     return msg      return msg
   
   from ECHO_root import ECHO_main
   
   #class ECHO_main(ECHO_root,ECHO_navigation):
   #    """echo main object combines ECHO_root and ECHO_navigation"""
   #    
   #    meta_type="ECHO_main"
   #    
   #    def __init__(self,id,title):
   #        """init"""
   #        self.id=id
   #        self.title=title
   #        self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.
   #        self.displayedMetaTypes=displayTypes
   #        
   #        
   #    manage_options = Folder.manage_options+(
   #        {'label':'Main Config','action':'ECHO_navigationConfigForm'},
   #        {'label':'Cache','action':'ECHO_cacheManageForm'},
   #        {'label':'Main Config','action':'ECHO_copyright_configForm'},
   #        {'label':'Change Weights','action':'changeWeights'},
   #        {'label':'Generate from RDF','action':'generateFromRDFForm'},
   #        {'label':'update Resource Catalog','action':'updateResourceCatalog'},
   #        {'label':'Copy MD for indexing and search','action':'copySearchFields'},
   #        )
   #
   #    
   #def manage_addECHO_mainForm(self):
   #    """Form for adding"""
   #    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)
   #    return pt()
   #
   #def manage_addECHO_main(self,id,title,RESPONSE=None):
   #    """Add an ECHO_main"""
   #    self._setObject(id,ECHO_main(id,title))
   #    
   #    obj=self._getOb(id)
   #    text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()
   #    
   #    manage_addPageTemplate(obj,'main_template',text=text)               
   #    
   #  
   #    if RESPONSE is not None:
   #        RESPONSE.redirect('manage_main')
Removed from v.1.205  
changed lines
  Added in v.1.310.2.8

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