[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.254 and 1.310.2.6

version 1.254, 2005/11/23 15:50:36 version 1.310.2.6, 2012/01/19 19:03:28
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.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 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, Print  #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 65  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 *
   
   try:
 from ECHO_language import *  from ECHO_language import *
   except:
       print "no echo_language"
       class ECHO_language:
           """ leere Klasse"""
           pass
   
 from ECHO_movie import *  from ECHO_movie import *
 import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen  import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
   import xmlrpclib
   
   import logging
   
   #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 83  def setECHO_collectionInformation(self,t Line 104  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):  class ECHO_locale(ZopePageTemplate):
         """localisierung"""          """localisierung"""
   
Line 92  class ECHO_locale(ZopePageTemplate): Line 204  class ECHO_locale(ZopePageTemplate):
                 self.lang=lang                  self.lang=lang
                 self.title=title                  self.title=title
                 self.label=label                  self.label=label
                 if text:              # default content
               if not text:
                   text = open(self._default_content_fn).read()
                   content_type = 'text/html'
                         self.pt_edit(text, content_type)                          self.pt_edit(text, content_type)
                 self.id=id                  self.id=id
   
Line 111  class ECHO_locale(ZopePageTemplate): Line 226  class ECHO_locale(ZopePageTemplate):
                 self.title=title                  self.title=title
                 self.label=label                  self.label=label
                 if not text is None:                  if not text is None:
                           if content_type is None:
                               content_type = self.content_type
                         self.pt_edit(text, content_type)                          self.pt_edit(text, content_type)
   
                 if RESPONSE is not None:                  if RESPONSE is not None:
Line 200  class ECHO_layoutTemplate(ZopePageTempla Line 317  class ECHO_layoutTemplate(ZopePageTempla
         if text is None:          if text is None:
             self._default_content_fn = os.path.join(package_home(globals()),'zpt','ECHO_%s_template_standard.zpt'%EchoType)              self._default_content_fn = os.path.join(package_home(globals()),'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 257  class ECHO_fullText(ZopePageTemplate,ECH Line 376  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')                  #return self().encode('latin-1','ignore')
                 dom=xml.dom.minidom.parseString(self().encode('utf-8','ignore'))                  try:
                      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()                  return pages[int(nr)-1].toxml()
Line 298  def manage_addECHO_fullText(self, id, ti Line 420  def manage_addECHO_fullText(self, id, ti
     return ''      return ''
   
   
 class ECHO_resource(CatalogAware,Folder,Persistent,ECHO_basis):  
     """ECHO Ressource"""  
     security=ClassSecurityInfo()  
     meta_type='ECHO_resource'  
     default_catalog='resourceCatalog'  
       
 #    viewClassificationList=viewClassificationListMaster  
   
     def PrincipiaSearchSource(self):  
            """Return cataloguable key for ourselves."""  
            return str(self)  
   
     getSubCols = ECHO_helpers.getSubCols  
   
     def reindex(self):  
         """generate fields for indexing and reindex"""  
         import urlparse  
         #TODO: korrigieren des metalink pfades konfigurierbar machen  
         splitted= [x for x in urlparse.urlparse(self.metalink)]  
         splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]  
           
         if splitted[0]=="http":  
             self.metalink=urlparse.urlunparse(splitted)  
           
   
         self.fullTextUrl=self.getFullTextXML(noredirect="yes")  
           
         #TODO: korrigieren relative url to absoluter url volltexten, konfigurierbar?  
         splitted= [x for x in urlparse.urlparse(self.fullTextUrl)]  
         if splitted[0]=="":  
             splitted[0]="http"  
             splitted[1]="foxridge.mpiwg-berlin.mpg.de"[0:]  
               
             self.fullTextUrl=urlparse.urlunparse(splitted)  
               
         self.imagePath=self.getImagePath()  
           
         self.reindex_object()  
     
     
     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:  
                             if value==self.getAccessRightMD():  
                                     ret+="<option selected>%s</option>"%value  
                             else:  
                                     ret+="<option>%s</option>"%value  
                     return ret+"</select>"  
   
             else:  
                     ret=""  
                     for value in values:  
                               
                             if value==self.getAccessRightMD():  
                                     ret+="""<input type="radio" name="%s" value="%s" checked>%s"""%(self.getId(),value,value)  
                             else:  
                                     ret+="""<input type="radio" name="%s" value="%s">%s"""%(self.getId(),value,value)  
                     return ret  
   
   
       
     def getAccessRightMD(self):  
                 """set accessright"""  
                 url=self.metalink  
   
                 try:  
                         geturl=""  
                         for line in ECHO_helpers.urlopen(url).readlines():  
                                 geturl=geturl+line  
   
   
                 except:  
                         return (None,"Cannot open: "+url)  
   
                 try:  
                         dom=xml.dom.minidom.parseString(geturl)  
                         root=dom.getElementsByTagName('resource')[0]  
                 except:  
                         return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
                 internal=dom.getElementsByTagName('internal')  
                 if internal:  
                         institution=dom.getElementsByTagName('institution')  
                         return getText(institution[0].childNodes)  
                   
                 free=dom.getElementsByTagName('free')  
                 if free:  
                         return "free"  
   
                 return "free" #default free  
   
     def changeAccessRightMD(self,accessright,RESPONSE=None):  
             """change the rights"""  
               
             params="accessright=%s"%accessright  
   
   
             #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()  
   
               
             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()  
   
             
             if RESPONSE is not None:  
                         RESPONSE.redirect('manage_main')  
   
                   
     def setAccessRightXML(self,accessright):  
                 """set accessright"""  
                 url=self.metalink  
   
                 try:  
                         geturl=""  
                         for line in ECHO_helpers.urlopen(url).readlines():  
                                 geturl=geturl+line   
   
   
                 except:  
                         return (None,"Cannot open: "+url)  
   
                 try:  
                         dom=xml.dom.minidom.parseString(geturl)  
                         root=dom.getElementsByTagName('resource')[0]  
                 except:  
                         return (None,"Cannot parse: "+url+"<br>"+geturl)  
   
                 metanodes=dom.getElementsByTagName('access-conditions')  
   
                 if not metanodes:  
                         nodenew=dom.createElement('access-conditions')  
                         root.appendChild(nodenew)  
                         metanode=nodenew  
                 else:  
                         metanode=metanodes[0]  
   
                 accesses=metanode.getElementsByTagName('access')  
   
                 if not accesses:  
                         nodenew2=dom.createElement('access')  
                         metanode.appendChild(nodenew2)  
                         metanode2=nodenew2  
                 else:  
                         metanode2=accesses[0]  
   
                 internal=metanode.getElementsByTagName('internal')  
   
                 if internal:  
                         metanode2.removeChild(internal[0]).unlink()  
   
                 free=metanode.getElementsByTagName('free')  
                   
                 if free:  
                         metanode2.removeChild(internal[0]).unlink()  
   
   
                 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()  
   
             try:  
                     fh=file(os.path.join(resourcepath,presentationXML),'w')  
                     fh.write("""<info>  
                     <author></author>  
                     <title>%s</title>  
                     <date></date>  
                     <display>yes</display>  
                     </info>"""%self.title)  
                     fh.close()  
                     return 1,self.getId()  
             except:  
                     if RESPONSE:  
                             RESPONSE.write("Error: %s\n"%self.getId())  
                     else:  
                             return None,self.absolute_url()  
   
               
     def setStartPage(self,startpage=None,RESPONSE=None):  
             """set start page, if no startpage defined use the generic one of the resource"""  
   
             if (not (type(startpage)==StringType)):  
                     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  
             #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))  
                                                                                                                                    
             ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML'+urllib.quote('?'+params))).read()  
           
               
             path=self.metalink  
               
             path=re.sub(self.REQUEST['SERVER_URL'],'',path)  
             path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)  
               
             path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  
             path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server  
             path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server  
             path=re.sub('http://content.mpiwg-berlin.mpg.de','',path) # falls content als server  
             path=re.sub('http://foxridge.rz-berlin.mpg.de','',path) # falls foxridge als server  
             path=re.sub('http://vision.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)   
   
   
             ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()  
   
             if RESPONSE is not None:  
                         RESPONSE.redirect('manage_main')  
   
     def changeViewerTemplateSetForm(self):  
             """change the viewer template set"""  
             pt=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)  
             # hack Pfad auf die Dokumente  
             path=self.metalink  
               
               
   
             path=re.sub('/index.meta','',path)   
   
             path=re.sub(self.REQUEST['SERVER_URL'],'',path)  
             path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)  
   
             path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  
             path=re.sub('http://foxridge.mpiwg-berlin.mpg.de:8080','',path) # falls foxridge als server  
             path=re.sub('http://foxridge.mpiwg-berlin.mpg.de','',path) # falls foxridge als server  
   
             path=re.sub('http://foxridge.rz-berlin.mpg.de:8080','',path) # falls foxridge als server  
             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  
   
             return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()  
   
   
             if RESPONSE is not None:  
                         RESPONSE.redirect('manage_main')  
   
       
   
     security.declarePublic('content_html')        
     def content_html(self):  
         """template fuer content"""  
         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:  
                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')    
                             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:  
                             return "<error>no images available</error>"  
   
       
     def getCopyrightsHTML(self):  
             """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""  
               
             if hasattr(self,'copyrightModel'):  
                     obj=self.copyrightModel  
                       
             else:  
                     return "ERROR"  
             ret=[]  
               
             for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID  
                       
                       
                     try:  
                         if hasattr(self.copyrightTypes,copyright[2]):  
                              copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])  
                              link="copyrightTypes/"+copyright[2]+'/copyright.html'  
                         else:  
                              copyrightTypeObj=getattr(obj,copyright[2])  
                              link="copyrightModel/"+copyright[2]+'/copyright.html'  
                                
                         label=copyrightTypeObj.label  
                         url=getattr(copyrightTypeObj, 'url', '')  
                               
                         if url!='':  
                                  ret.append((url,copyright[0],copyright[1],copyright[2],label))  
                         else:  
                                 if hasattr(copyrightTypeObj, 'copyright.html'):  
                                      ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))  
                                 else:  
                                      ret.append(('empty',copyright[0],copyright[1],copyright[2],label))  
                     except:  
                             """nothing"""  
                       
             return ret  
               
     def getInstitutionsHTML(self):  
                 """gibt Liste der foerdernden Institutionen aus"""  
                   
                 if hasattr(self,'support'):  
                         obj=self.support  
                         ret=obj.getSupporter()  
                         return ret  
                 else:  
                         return ''  
                           
       
     def getCredits(self):  
         """Ausgabe der credits"""  
         if self.credits:  
             return self.credits  
         else:  
             return []  
   
   
       
     def __init__(self,id,link,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):  
   
         self.id = id  
         """Festlegen der ID"""  
           
         self.label = label  
         self.link= link  
         self.metalink=metalink  
         self.title=title  
         self.weight=weight  
         self.credits=toList(credits)  
         self.description=description  
         self.contentType=contentType  
         self.copyrightType=copyrightType  
         self.renderingType=renderingType  
         self.responsible=responsible  
         self.resourceID=resourceID  
           
         if coords:  
             coordsnew=[ string.split(x,",") for x in coords]  
         else:  
             coordsnew=[]  
           
         self.coords=coordsnew  
 #       self.viewClassification=""  
   
   
   
     def getContentType(self):  
             try:  
                     return self.contentType  
             except:  
                     return ""  
   
     def getCopyrightType(self):  
             try:  
                     return self.copyrightType  
             except:  
                     return ""  
   
     def getRenderingType(self):  
             try:  
                     return self.renderingType  
             except:  
                     return ""  
   
     def ECHO_resource_config(self):  
         """Main configuration"""  
   
         if not hasattr(self,'weight'):  
             self.weight=""  
   
         pt=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.metaDataHash[data_neu]=getattr(self,data)[0:]  
   
           
         pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')  
         return pt()  
   
   
       
   
     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):  
         """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,fieldNameTest,empty=None,generic=None):  
             """get md values"""  
             #TODO: cache mappinghash  
               
             fieldName=None  
             if generic:  
                 ct=self.contentType.replace(" ","_").lower()  
                   
                 #caching  
                 if not hasattr(self,'_v_mapHash'): #noch keine cachevariable  
                     self._v_mapHash={}  
                       
                 tmp=self._v_mapHash.get(ct,None)   
                 if tmp: #teste ob type schon existiert  
                     fieldName=tmp.get(fieldNameTest,None)  
                 else:  
                     self._v_mapHash[ct]={}  
                       
                 #noch nicht gecached      
                 if not fieldName and hasattr(self.standardMD,ct):      
                     fieldName=getattr(self.standardMD,ct).generateMappingHash()[fieldNameTest][0]  
                     self._v_mapHash[ct][fieldNameTest]=fieldName  
             if not fieldName:  
                 fieldName=fieldNameTest    
             if not empty:  
                #FIXME: warum gibt es manchmal kein metadatahas  
                 try:  
                     return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)  
                 except:  
                     zLOG.LOG("ECHO (line 1069)",zLOG.ERROR,"no md hash for %s"%self.getId())   
                     return ""  
                     
             else:  
   
                 return self.metaDataHash.get(fieldNameTest,empty)  
   
     getFieldValue=getMDValue #depricated  
   
     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):  
             """return bibliographical metadata as stored in the object"""  
               
             try:  
                       
                     return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")  
             except:  
                     return "<error> no metadata stored</error>"  
       
     def getXQueryMetaData(self,xquery):  
                 '''  
                 execute an xquery on the metadata and returns a list of tuples,   
                 each tuple represent the content of the node as text and the whole node as xml-fragment  
                 @param xquery: xquery auf den metadaten  
                 '''  
                   
                 try:  
                         md=writeMetadata(self.metalink,self.metaDataHash,xmlfrag="yes")  
                 except:  
                         return None  
   
                 dom = NonvalidatingReader.parseString(md,"http://www.mpiwg-berlin.mpg.de/")  
                   
                 results=Ft.Xml.XPath.Evaluate(xquery, contextNode=dom)  
               
                 ret=[]  
                 for result in results:  
                       
                     buf = cStringIO.StringIO()  
                     PrettyPrint(result, stream=buf)  
                     str = buf.getvalue()[0:]  
                     buf.close()  
                     ret.append((getTextFromNode(result),str))   
                           
                 return ret  
           
     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)  
         self.link=link  
         self.metalink=metalink  
           
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
               
               
     manage_options = Folder.manage_options+(  
         {'label':'Main Config','action':'ECHO_resource_config_main'},  
         {'label':'Change 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 getMetaDataHash(self):  
             """md hash"""  
             return self.metaDataHash  
       
     def setFieldValue(self,field,value):  
         """get value"""  
         #TODO: remove setFieldValue  
           
         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.getMDValue(field,generic="yes"))  
       
   
     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')  
               
             return "OK:",self.absolute_url(),self.contentType  
           
     def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"):  
         """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 self.contentType) or (overwrite=="yes"):  
                 self.contentType=metadict['bib_type'].lower()  
                   
         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  
   
           
           
         self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])  
           
   
                   
         if template=="yes":  
                 pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')  
                 return pt()  
   
           
   
       
       
     def ECHO_getMD(self,item):  
         """Ausgabe der MD"""  
         return getattr(self,item)  
   
     def checkRDF(self,path):  
             """check if pdf in the path"""  
             try:  
                     for fileName in os.listdir(path):  
                             if os.path.splitext(fileName)[1]==".pdf":  
                                     return os.path.join(path,fileName)  
                     return None  
             except:  
                     return None  
               
               
     security.declareProtected('View','index_html')  
     def index_html(self):  
         """standard page"""  
         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:  
                     return sp[1]()  
   
             #pruefen ob irgendwo ein template  
             if hasattr(self,'startpage_index_template'):   
                     return self.startpage_index_template()  
   
             #generisches template ausgeben  
               
             pt=zptFile(self, 'zpt/ECHO_startpage_index_template_standard.zpt')  
             pt.content_type="text/html"  
             return pt()  
   
     def toc_html(self):  
               
             sp=self.ZopeFind(self,obj_ids=['toc.html'])  
                       
             if sp:  
                     return sp[0][1]()  
   
   
     security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination  
   
     def generate_label(self):  
         """Erzeugt_standard_Label aus Template"""  
         pt=getattr(self,"label_template_"+self.contentType.lower())  
   
         self.label=pt()[0:]  
         return pt()  
   
     security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination  
   
     def generate_title(self,RESPONSE=None):  
         """Erzeugt_standard_Label aus Template"""  
         pt=getattr(self,"label_template_"+self.contentType.lower())  
   
         self.title=pt()[0:]  
           
         return pt()  
   
 Globals.InitializeClass(ECHO_resource)  
   
 def manage_addECHO_resourceForm(self):  
         """Form for adding a ressource"""  
         pt=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):  
     """addresource"""  
   
     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):  class ECHO_externalLink(Folder,ECHO_basis):
Line 1448  class ECHO_externalLink(Folder,ECHO_basi Line 432  class ECHO_externalLink(Folder,ECHO_basi
         """template fuer content"""          """template fuer content"""
         ret= ECHO_basis.content_html(self,'externalLink')          ret= ECHO_basis.content_html(self,'externalLink')
                   
           if type(ret) is StringType:
               return ret.decode('utf-8')
           else:
              return ret
                   
         try:  
             return ret.encode('utf-8')  
           
         except:  
                     try:   
                         return ret.decode('latin-1')  
                     except:  
                             
                         return ret  
           
     def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords):      def __init__(self,id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType):
   
         self.id = id          self.id = id
         """Festlegen der ID"""          """Festlegen der ID"""
Line 1474  class ECHO_externalLink(Folder,ECHO_basi Line 454  class ECHO_externalLink(Folder,ECHO_basi
         self.responsible=responsible          self.responsible=responsible
         coordsnew=[ string.split(x,",") for x in coords]          coordsnew=[ string.split(x,",") for x in coords]
         self.coords=coordsnew          self.coords=coordsnew
           self.linkType = linkType        # Linktypen 'otherPresentation','external'
           
   
     def ECHO_externalLink_config(self):      def ECHO_externalLink_config(self):
         """Main configuration"""          """Main configuration"""
Line 1489  class ECHO_externalLink(Folder,ECHO_basi Line 471  class ECHO_externalLink(Folder,ECHO_basi
         return pt()          return pt()
           
   
     def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):      def changeECHO_externalLink(self,link,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
         """Aenderung der Properties"""          """Aenderung der Properties"""
         setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)          setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
   
         self.link=link          self.link=link
           self.linkType = linkType
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
       def getLinkType(self):
           """ return linkType """
           if hasattr(self,"linkType"):
                   return self.linkType
           else :
                   return 'otherPresentation'
                           
     manage_options = Folder.manage_options+(      def setLinkType(self,type):
           """ set linkType """
           self.linkType = type
           
       def checkLink(self):
           """ returns tuple (isWorking,Error) """        
           try:
               urllib2.urlopen(self.link)
               return (True, '')
           except urllib2.HTTPError, e:
               return (False, e.code)
           except urllib2.URLError, e:
               return (False, str(e.reason))
           except:
               return (False, 'unknown Error')
               
               
       manage_options = (
         {'label':'Main Config','action':'ECHO_externalLink_config'},          {'label':'Main Config','action':'ECHO_externalLink_config'},
         {'label':'Graphic Coords','action':'ECHO_graphicEntry'},          {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         )          )+Folder.manage_options
   
                   
     def index_html(self):      def index_html(self):
Line 1509  class ECHO_externalLink(Folder,ECHO_basi Line 515  class ECHO_externalLink(Folder,ECHO_basi
                   
         return self.REQUEST.RESPONSE.redirect(self.link)          return self.REQUEST.RESPONSE.redirect(self.link)
   
   
 def manage_addECHO_externalLinkForm(self):  def manage_addECHO_externalLinkForm(self):
         """Form for external Links"""          """Form for external Links"""
         pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')          pt=zptFile(self, 'zpt/AddECHO_externalLinkForm.zpt')
         return pt()          return pt()
   
   
 def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None):  def manage_addECHO_externalLink(self,id,title,label,description,contentType,responsible,link,weight,coords=None,credits=None,RESPONSE=None,linkType='otherPresentation'):
     """Add an external Link"""      """Add an external Link"""
   
     newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords)      newObj=ECHO_externalLink(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
   
Line 1571  class ECHO_link(ECHO_externalLink): Line 578  class ECHO_link(ECHO_externalLink):
 #                  #                
 #                        return ret  #                        return ret
 #          #        
           def getCopyrightsHTML(self):
               """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
               
               if hasattr(self,'copyrightModel'):
                       obj=self.copyrightModel
                       
               else:
                       return "ERROR"
               ret=[]
               
               for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
                       
   
                       try:
                           if hasattr(self.copyrightTypes,copyright[2]):
                                copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
                                link="copyrightTypes/"+copyright[2]+'/copyright.html'
                           else:
                                copyrightTypeObj=getattr(obj,copyright[2])
                                link="copyrightModel/"+copyright[2]+'/copyright.html'
                                
                           label=copyrightTypeObj.label
                           url=getattr(copyrightTypeObj, 'url', '')
                               
                           if url!='':
                                    ret.append((url,copyright[0],copyright[1],copyright[2],label))
                           else:
                                   if hasattr(copyrightTypeObj, 'copyright.html'):
                                        ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
                                   else:
                                        ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
                       except:
                               """nothing"""
                       
               return ret
               
           def getInstitutionsHTML(self):
                   """gibt Liste der foerdernden Institutionen aus"""
                   
                   if hasattr(self,'support'):
                           obj=self.support
                           ret=obj.getSupporter()
                           return ret
                   else:
                           return ''
                           
           def getOwnerOriginalsHTML(self):
                  """gibt Liste der foerdernden Institutionen aus"""
                  
                  if hasattr(self,'ownerOriginal'):
                          obj=self.ownerOriginal
                          ret=obj.getOwner()
                          return ret
                  else:
                          return ''
       
           def getDigiCopyByHTML(self):
                  """gibt Liste der foerdernden Institutionen aus"""
                  
                  if hasattr(self,'digiCopyBy'):
                          obj=self.digiCopyBy
                          ret=obj.getDigiCopyBy()
                          return ret
                  else:
                          return ''
                                   
         def index_html(self):          def index_html(self):
                 """standard link"""                  """standard link"""
Line 1603  def manage_addECHO_linkForm(self): Line 674  def manage_addECHO_linkForm(self):
         return pt()          return pt()
   
   
 def manage_addECHO_link(self,id,title,label,description="",contentType="",responsible="",link="",weight="",coords=[],credits=None,RESPONSE=None):  def manage_addECHO_link(self,id,title,label,description="",contentType="",responsible="",link="",weight="",coords=[],credits=None,linkType="external",RESPONSE=None):
     """Add an external Link"""      """Add an external Link"""
   
     newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords)      newObj=ECHO_link(id,link,title,label,description,contentType,responsible,credits,weight,coords,linkType)
   
     self._setObject(id,newObj)      self._setObject(id,newObj)
           
Line 1616  def manage_addECHO_link(self,id,title,la Line 687  def manage_addECHO_link(self,id,title,la
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                   
   
 class ECHO_collection(Folder, Persistent, Implicit, Cacheable,ECHO_basis):  class ECHO_collection(CatalogAware, Folder, Persistent, Implicit, Cacheable,ECHO_basis):
     """ECHO Collection"""      """ECHO Collection"""
   
       management_page_charset="utf-8"
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='ECHO_collection'      meta_type='ECHO_collection'
       default_catalog='resourceCatalog'
       
       rootMetaTypes = ['ECHO_root', 'ECHO_main', 'ECHO_nav']
       
 #    viewClassificationList=viewClassificationListMaster  #    viewClassificationList=viewClassificationListMaster
     displayTypes=displayTypes      displayTypes=displayTypes
   
     path="/mpiwg/online/permanent/shipbuilding"      path="/mpiwg/online/permanent/shipbuilding"
   
       def getSection(self, crumbs=None):
           """returns the current section name"""
           # use breadcrumbs if available
           if crumbs is not None and len(crumbs) > 0:
               return crumbs[0][2].getId()
       
           p = self
           sec = None
           # descend parents to the root (and remember the last id)
           while p is not None and p.meta_type 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()
           
       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
           ret=None
           
           for name in zf.namelist():
                  ds,fn=tempfile.mkstemp()
                  tf=file(fn,"w")
                  x=zf.read(name)
                  tf.write(x)
                  tf.close()
                  try:
                      self._importObjectFromFile(fn,set_owner=1)
                  except:
                      if not ret:
                          ret=""
                      ret+="Cannot import: %s (Already existing?)<br>"%name
              os.close(ds)
                  os.remove(fn)
   
           zf.close()
   
           if ret:
               return """<html><body>%s</body></html>"""%ret
           if RESPONSE:
               RESPONSE.redirect(self.absolute_url())
           
       def exportObjects_html(self,RESPONSE):
           """Export objects"""
           
           pt=zptFile(self, 'zpt/exportObjects.zpt')
           pt.content_type="text/html"
           return pt()
       
       def exportObjects(self,ids,RESPONSE=None):
           """export objects with type id"""
           if not (type(ids) is ListType):
               ids=[ids]
           
           tmpdir=tempfile.mkdtemp() # create tempdir
           objs=self.ZopeFind(self,obj_ids=ids)
           tmpfile=tempfile.mkstemp()[1]
   
           zf=zipfile.ZipFile(tmpfile,"w")
           for obj in objs:
   
               f = os.path.join(tmpdir, '%s.zexp' %obj[0])
               #print E.absolute_url()
   
               obj[1]._p_jar.exportFile(obj[1]._p_oid, f)
   
               zf.write(f,obj[0])
           
           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()
               
       def getMDValueSimpleSearchField(self):
             """returns value for simple search"""
             return " ".join([self.title,self.description])
                                
     def getTitleAndLabel(self):      def getTitleAndLabel(self):
         """gibt title und label zurueck"""          """gibt title und label zurueck"""
         return (getattr(self,'title',''),getattr(self,'label',''))          return (getattr(self,'title',''),getattr(self,'label',''))
Line 1673  class ECHO_collection(Folder, Persistent Line 874  class ECHO_collection(Folder, Persistent
   
                             if obj.meta_type=="ECHO_mapText":                              if obj.meta_type=="ECHO_mapText":
                                     if splitted[1]=="en":                                      if splitted[1]=="en":
                                             obj.locale_en.pt_edit(REQUEST.form[key],None)                                              obj.locale_en.pt_edit(REQUEST.form[key],obj.locale_en.content_type)
                                     else:                                      else:
                                             obj.pt_edit(REQUEST.form[key],None)                                              obj.pt_edit(REQUEST.form[key],obj.content_type)
                             else:                              else:
                                     text=obj.ZopeFind(obj,obj_metatypes=['ECHO_mapText'])                                      text=obj.ZopeFind(obj,obj_metatypes=['ECHO_mapText'])
                                     if splitted[1]=="en":                                      if splitted[1]=="en":
                                                                                           
                                             text[0][1].locale_en.pt_edit(REQUEST.form[key],None)                                              text[0][1].locale_en.pt_edit(REQUEST.form[key],text[0][1].locale_en.content_type)
                                     else:                                      else:
                                             text[0][1].pt_edit(REQUEST.form[key],None)                                              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')
   
Line 1697  class ECHO_collection(Folder, Persistent Line 898  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 1734  class ECHO_collection(Folder, Persistent Line 942  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 1742  class ECHO_collection(Folder, Persistent Line 959  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 1824  class ECHO_collection(Folder, Persistent Line 1045  class ECHO_collection(Folder, Persistent
                             pass                              pass
             return ret              return ret
                 
     def importCollection(self,path=None,RESPONSE=None):      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"""
                   
         if path is None:          if path is None:
Line 1837  class ECHO_collection(Folder, Persistent Line 1058  class ECHO_collection(Folder, Persistent
                           
             if fileName:              if fileName:
                                   
                 tempPath=re.sub("/mpiwg/online","",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)
                  
                   link=viewerUrl%(path+"/"+fileName+"/pageimg")
                                   
                 metalink=self.path+"/"+fileName+"/index.meta"                  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 1894  class ECHO_collection(Folder, Persistent Line 1120  class ECHO_collection(Folder, Persistent
         else:          else:
             return None              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)  
   
             for resource in resources:          if RESPONSE is not None:
                       RESPONSE.write("<p>Done</p></body></html>")
   
                     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 1943  class ECHO_collection(Folder, Persistent Line 1160  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()
Line 1960  class ECHO_collection(Folder, Persistent Line 1177  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)  
   
           
     def getPartnerCopyright(self,name,sonst="generic"):      def getPartnerCopyright(self,name,sonst="generic"):
Line 1991  class ECHO_collection(Folder, Persistent Line 1198  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 2019  class ECHO_collection(Folder, Persistent Line 1228  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')      security.declarePublic('getImageTag')
Line 2058  class ECHO_collection(Folder, Persistent Line 1268  class ECHO_collection(Folder, Persistent
             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 2101  class ECHO_collection(Folder, Persistent Line 1327  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 2148  class ECHO_collection(Folder, Persistent Line 1379  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 2166  class ECHO_collection(Folder, Persistent Line 1397  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+(
Line 2175  class ECHO_collection(Folder, Persistent Line 1407  class ECHO_collection(Folder, Persistent
         {'label':'Localize','action':'localizeObjects'},          {'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 Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},          {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},
         {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},  
         {'label':'ImportCollection','action':'importCollection'},          {'label':'ImportCollection','action':'importCollection'},
         {'label':'Copy MD for indexing and search','action':'copySearchFields'},          {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},
         )          )
   
           
Line 2208  class ECHO_collection(Folder, Persistent Line 1439  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,prefix="",suffix=""):      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 2219  class ECHO_collection(Folder, Persistent Line 1450  class ECHO_collection(Folder, Persistent
         self.isAlwaysClickable=isAlwaysClickable          self.isAlwaysClickable=isAlwaysClickable
         self.prefix=prefix[0:]          self.prefix=prefix[0:]
         self.suffix=suffix[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 2238  class ECHO_collection(Folder, Persistent Line 1470  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()
   
Line 2248  class ECHO_collection(Folder, Persistent Line 1487  class ECHO_collection(Folder, Persistent
     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'):
               # use 'main_index_template' in acquisition path
             ret=self.main_index_template.__of__(self)(self.main_template)              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 2278  class ECHO_collection(Folder, Persistent Line 1529  class ECHO_collection(Folder, Persistent
         #print "NN",argv          #print "NN",argv
         ret = ECHO_basis.content_html(self,'collection')          ret = ECHO_basis.content_html(self,'collection')
                   
         try:          if type(ret) is StringType:
                 return ret.encode('utf-8')                 return ret.decode('utf-8')
         except:          else:
               
             try:   
                 return ret.decode('latin-1')  
             except:  
                   
                 return ret                  return ret
                             
                
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
         if self.credits:          if self.credits:
Line 2297  class ECHO_collection(Folder, Persistent Line 1544  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 2323  class ECHO_collection(Folder, Persistent Line 1570  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,mapColTypes=['ECHO_collection','ECHO_resource','ECHO_link','ECHO_externalLink']):      def getAllMapAreas(self,mapColTypes=None):
         """Give list of coordinates"""          """Give list of coordinates"""
           if mapColTypes is None:
               mapColTypes=['ECHO_collection','ECHO_resource','ECHO_link','ECHO_externalLink']
                   
         areas=[]          areas=[]
         for entry in self.getSubCols(subColTypes=mapColTypes):          for entry in self.getSubCols(subColTypes=mapColTypes):
Line 2346  class ECHO_collection(Folder, Persistent Line 1595  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 2354  def manage_addECHO_collectionForm(self): Line 1609  def manage_addECHO_collectionForm(self):
         return pt()          return pt()
   
   
 def manage_addECHO_collection(self,id,title,label,description="",contentType="",responsible="",weight=0,sortfield="weight",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 2388  class ECHO_group(ECHO_collection): Line 1643  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 2582  class ECHO_userFolder(UserFolder): Line 1837  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 2643  class ECHO_root(Folder,Persistent,Implic Line 1899  class ECHO_root(Folder,Persistent,Implic
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
           
     meta_type="ECHO_root"      meta_type="ECHO_root"
       management_page_charset="utf-8"
                   
       getSubCols = ECHO_helpers.getSubCols
   
       manage_options=Folder.manage_options+(
                   {'label':'Main Config','action':'ECHO_copyright_configForm'},
                   {'label':'Change Weights','action':'changeWeights'},
                   {'label':'Generate from RDF','action':'generateFromRDFForm'},
                   {'label':'update Resource Catalog','action':'updateResourceCatalog'},
                  )
   
   
   
   
       def getECHORootURL(self):
           return self.absolute_url()
       
       def getECHORoot(self):
           return self
   
       def getBrowserType(self):
           """returns browserType object"""
           return browserType(self)
           
     def mod_re_sub(self,pattern,replace,string):      def mod_re_sub(self,pattern,replace,string):
         """re.sub aus mod re zur Verfuegung stellen"""          """re.sub aus mod re zur Verfuegung stellen"""
Line 2676  class ECHO_root(Folder,Persistent,Implic Line 1954  class ECHO_root(Folder,Persistent,Implic
                   
         for resource in resources:          for resource in resources:
             resource[1].reindex()              resource[1].reindex()
             print "<p> done %s </p>\n"              #print "<p> done %s </p>\n"
             if RESPONSE:              if RESPONSE:
                 RESPONSE.write("<p> done %s </p>\n"%resource[0])                  RESPONSE.write("<p> done %s </p>\n"%resource[0])
                                   
         if RESPONSE:          if RESPONSE:
             RESPONSE.write("<p> ok </p></html></body>\n")              RESPONSE.write("<p> ok </p></html></body>\n")
                           
     def printer(self,txt):  
         print txt  
         print txt[2]  
         print txt[2].getImageTag()  
         print "HO"  
         return txt[2].getImageTag()  
   
     def printer2(self,txt):  
         print txt  
   
   
     def item2(self,txt):  
         return txt[2]  
   
     def setLanguage(self,lang):      def setLanguage(self,lang):
             """Set language cookie"""              """Set language cookie"""
Line 2710  class ECHO_root(Folder,Persistent,Implic Line 1975  class ECHO_root(Folder,Persistent,Implic
                           
             self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")              self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
             self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1'])              self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1'])
               
     def getLanguage(self):      def getLanguage(self):
             """get language cookie"""              """get language cookie"""
             lang= self.REQUEST.cookies.get('lang_exhibition','de')              lang= self.REQUEST.cookies.get('lang_exhibition','de')
Line 2816  class ECHO_root(Folder,Persistent,Implic Line 2082  class ECHO_root(Folder,Persistent,Implic
                     global key                      global key
                     global value                      global value
                     seq=""                      seq=""
                     if name=="RDF:Seq":                      if name=="rdf:Seq":
                             key=attrs.get('RDF:about')                              key=attrs.get('rdf:about')
                             try: # teste ob liste                              try: # teste ob liste
                                     x=seqs[key][0]                                      x=seqs[key][0]
                             except:                              except:
Line 2825  class ECHO_root(Folder,Persistent,Implic Line 2091  class ECHO_root(Folder,Persistent,Implic
                                     seqs[key]=[]                                      seqs[key]=[]
   
                                           
                     elif name=="RDF:Description":                      elif name=="rdf:Description":
                             key=attrs.get('RDF:about')                              key=attrs.get('rdf:about')
                                                           
   
                     elif name=="RDF:li":                      elif name=="rdf:li":
                             name=attrs.get('RDF:resource')                              name=attrs.get('rdf:resource')
                             seqs[key].append(name)                              seqs[key].append(name)
   
                     elif name=="ECHONAVIGATION:type":                      elif name=="echonavigation:type":
                             value="type"                              value="type"
   
                     elif name=="ECHONAVIGATION:name":                      elif name=="echonavigation:name":
                             value="name"                              value="name"
                     elif name=="ECHONAVIGATION:linkClickable":                      elif name=="echonavigation:linkClickable":
                             value="linkClickable"                              value="linkClickable"
                                                           
             def end_element(name):              def end_element(name):
Line 2899  class ECHO_root(Folder,Persistent,Implic Line 2165  class ECHO_root(Folder,Persistent,Implic
                 pt=zptFile(self, 'zpt/changeWeightForm')                  pt=zptFile(self, 'zpt/changeWeightForm')
                 pt.content_type="text/html"                  pt.content_type="text/html"
                 return pt()                  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):      def getRDF(self,urn=None):
             """rdf of the collection"""              """rdf of the collection"""
Line 2929  class ECHO_root(Folder,Persistent,Implic Line 2174  class ECHO_root(Folder,Persistent,Implic
   
             ret=getRDFDescription(self,self.absolute_url(),urn=urn)              ret=getRDFDescription(self,self.absolute_url(),urn=urn)
                           
             li="""<RDF:li RDF:resource="%s" />\n"""              li="""<rdf:li rdf:resource="%s" />\n"""
   
                           
             for content in contents:              for content in contents:
                     ret+=content[1].getRDF()+"\n"                      ret+=content[1].getRDF()+"\n"
                                           
             ret+="""<RDF:Seq RDF:about="%s">\n"""%urn              ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
             for content in contents:              for content in contents:
                     nurn=content[1].absolute_url()                      nurn=content[1].absolute_url()
                     ret+=li%nurn                      ret+=li%nurn
             return ret+"</RDF:Seq>"              return ret+"</rdf:Seq>"
                           
   
     def showContent(self,path):      def showContent(self,path):
Line 2965  class ECHO_root(Folder,Persistent,Implic Line 2210  class ECHO_root(Folder,Persistent,Implic
             return ret              return ret
   
     def getValueFromClass(self,field,found):      def getValueFromClass(self,field,found):
             """retattribute falss existing"""              """ret attribute if existing"""
             try:              try:
                                           
                     return getattr(found,field).decode('ascii','ignore')  
                       return getattr(found,field)#.decode('ascii','ignore')
   
   
   
             except:              except:
                       logging.error("can't: decode: %s"%repr(field))
                       logging.error("      %s %s"%(sys.exc_info()[0],sys.exc_info()[1]))
                     return ""                      return ""
   
     security.declarePublic('getImageTag')      security.declarePublic('getImageTag')
Line 3206  class ECHO_root(Folder,Persistent,Implic Line 2457  class ECHO_root(Folder,Persistent,Implic
   
     def formatAscii(self,str,url=None):      def formatAscii(self,str,url=None):
         """ersetze ascii umbrueche durch <br>"""          """ersetze ascii umbrueche durch <br>"""
         #url=None  
       if not str: 
               return ""
   
         if url:          if url:
                           
             retStr=""              retStr=""
Line 3218  class ECHO_root(Folder,Persistent,Implic Line 2472  class ECHO_root(Folder,Persistent,Implic
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)                  retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
             str=retStr              str=retStr
         if str:          if str:
             return re.sub(r"[\n]","<br/>",str)              str = re.sub(r"[\n]","<br/>",str)
               return unicodify(str)
         else:          else:
             return ""              return u""
                   
     link2html=vlp_xmlhelpers.link2html      link2html=vlp_xmlhelpers.link2html
       related2html=vlp_xmlhelpers.related2html
   
     xml2html=vlp_xmlhelpers.xml2html      xml2html=vlp_xmlhelpers.xml2html
     
Line 3255  class ECHO_root(Folder,Persistent,Implic Line 2511  class ECHO_root(Folder,Persistent,Implic
     def getPartners(self):      def getPartners(self):
         """Get list of Partners. Presently only from a subfolder partners"""          """Get list of Partners. Presently only from a subfolder partners"""
         if hasattr(self,'partners'):                      if hasattr(self,'partners'):            
                 return [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]                  ret = [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]
                   def sort_title(one, another) : return cmp(one.title, another.title)
                   ret.sort(sort_title)
                   return ret
         else:          else:
                 return []                  return []
       
Line 3310  class ECHO_root(Folder,Persistent,Implic Line 2569  class ECHO_root(Folder,Persistent,Implic
                           
             ret="""<html><body><h2>Resources in ECHO</h3>"""              ret="""<html><body><h2>Resources in ECHO</h3>"""
                           
             resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)              resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource','VLP_resource'],search_sub=1)
             ret+="""<h3>Found %i resources</h3>"""%len(resources)              ret+="""<h3>Found %i resources</h3>"""%len(resources)
             resources.sort(sortHTML)              resources.sort(sortHTML)
             for resource in resources:              for resource in resources:
Line 3336  class ECHO_root(Folder,Persistent,Implic Line 2595  class ECHO_root(Folder,Persistent,Implic
             """gebe all ressourcen aus"""              """gebe all ressourcen aus"""
             ret="""<?xml version="1.0" ?>              ret="""<?xml version="1.0" ?>
                      <index>"""                       <index>"""
             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):              for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource','VLP_resource'],search_sub=1):
   
                     echo_url=resource[1].absolute_url()                      echo_url=resource[1].absolute_url()
                     if hasattr(resource[1],'link'):                      if hasattr(resource[1],'link'):
Line 3353  class ECHO_root(Folder,Persistent,Implic Line 2612  class ECHO_root(Folder,Persistent,Implic
             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")              self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
             self.REQUEST.RESPONSE.write(ret)              self.REQUEST.RESPONSE.write(ret)
   
       def getCollectionsXML(self,viewerType=None,filter=None):
               """gebe collections aus"""
               ret="""<?xml version="1.0" ?>
                        <index>"""
               for resource in self.ZopeFind(self,obj_metatypes=['ECHO_collection','ECHO_group'],search_sub=1):
   
                       echo_url=resource[1].absolute_url()
                    
                       ret+="""\n<collection echoLink="%s"/>"""%urllib.quote(echo_url,safe='/:?')
               ret +="""\n</index>"""
               
               self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")
               self.REQUEST.RESPONSE.write(ret)
   
     def getFullTextsXML(self,viewerType=None,filter=None):      def getFullTextsXML(self,viewerType=None,filter=None):
             """gebe all ressourcen aus"""              """gebe all ressourcen aus"""
             ret="""<?xml version="1.0" ?>              ret="""<?xml version="1.0" ?>
Line 3438  class ECHO_root(Folder,Persistent,Implic Line 2711  class ECHO_root(Folder,Persistent,Implic
         inst=self.ZopeFind(self.institutions, obj_ids=[id])          inst=self.ZopeFind(self.institutions, obj_ids=[id])
         return inst          return inst
   
       def updateResourceCatalog(self,REQUEST,RESPONSE):
           """update ressource catalog"""
           catalog=getattr(self,'resourceCatalog',None)
           if not catalog:
               return """<html><body><h3>No resourceCatalog available</h3></body></html>"""
           
           else:
               class element:
                   def __init__(self,group,name):
                       self.group=group
                       self.name=name
               catalog.manage_delObjects('author splitter')
               #elements=[element('Stop Words',""" Don't remove stop words' """),element('Word Splitter','ECHO author splitter')]
               elements=[element('Word Splitter','ECHO author splitter')]
               manage_addLexicon(catalog,id="author splitter",elements=elements)
               
               return catalog.manage_catalogReindex(REQUEST,RESPONSE,'manage_main')
               
           
       def checkMetaDataLinks(self,correct=None):
           """check all metadatalinks and if correct is set change the servername to content.mpiwg-berlin.mpg.de"""
           
           self.REQUEST.RESPONSE.write("<html><body>")
           for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):
               metalink=resource[1].metalink
           
               try:
                   url=urllib.urlopen(metalink)
               except:
                   
                   self.REQUEST.RESPONSE.write("<p>ERROR (opening %s):"%resource[1].absolute_url() +" -- %s %s <br>"%sys.exc_info()[0:2])
                   self.REQUEST.RESPONSE.write("-----------%s"%metalink)
               
                   if correct:
                       urlparsed=[x for x in urlparse.urlparse(metalink)]
                       urlparsed[1]="content.mpiwg-berlin.mpg.de"
                       neu=urlparse.urlunparse(urlparsed)
                       resource[1].metalink=neu[0:]
                       self.REQUEST.RESPONSE.write("----------changed to:%s)"%neu)
                   
 def manage_addECHO_root(self,id,title,RESPONSE=None):  def manage_addECHO_root(self,id,title,RESPONSE=None):
     """Add an ECHO_root"""      """Add an ECHO_root"""
Line 3500  def manage_addECHO_copyrightType(self,id Line 2812  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 3620  class ECHO_linkList(ZopePageTemplate,ECH Line 2849  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 3631  class ECHO_linkList(ZopePageTemplate,ECH Line 2860  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 3731  def manage_addECHO_support(self, id,inst Line 2962  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 3851  def repairCoords(self): Line 3195  def repairCoords(self):
                     col.addMapArea(area)                      col.addMapArea(area)
         msg += "\nDone!"          msg += "\nDone!"
         return msg          return msg
   
   from ECHO_Nav import ECHO_navigation
   
   class ECHO_main(ECHO_root,ECHO_navigation):
       """echo main object combines ECHO_root and ECHO_navigation"""
       
       meta_type="ECHO_main"
       
       def __init__(self,id,title):
           """init"""
           self.id=id
           self.title=title
           self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.
           self.displayedMetaTypes=displayTypes
           
           
       manage_options = Folder.manage_options+(
           {'label':'Main Config','action':'ECHO_navigationConfigForm'},
           {'label':'Cache','action':'ECHO_cacheManageForm'},
           {'label':'Main Config','action':'ECHO_copyright_configForm'},
           {'label':'Change Weights','action':'changeWeights'},
           {'label':'Generate from RDF','action':'generateFromRDFForm'},
           {'label':'update Resource Catalog','action':'updateResourceCatalog'},
           {'label':'Copy MD for indexing and search','action':'copySearchFields'},
           )
   
       
   def manage_addECHO_mainForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)
       return pt()
   
   def manage_addECHO_main(self,id,title,RESPONSE=None):
       """Add an ECHO_main"""
       self._setObject(id,ECHO_main(id,title))
       
       obj=self._getOb(id)
       text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()
       
       manage_addPageTemplate(obj,'main_template',text=text)               
       
     
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
Removed from v.1.254  
changed lines
  Added in v.1.310.2.6

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