[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.234 and 1.294

version 1.234, 2005/09/12 21:51:00 version 1.294, 2008/02/04 18:49:13
Line 15  try: Line 15  try:
 except:  except:
     print "PDF generation will not work"      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 35  from Globals import DTMLFile
 import Globals  import Globals
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate,manage_addPageTemplate
 from Globals import Persistent, package_home  from Globals import Persistent, package_home
 from Acquisition import Implicit  from Acquisition import Implicit
   from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
   
 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  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
   
 try:  try:
     from psycopg import libpq      from psycopg import libpq
Line 64  import urllib Line 69  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 *
 from ECHO_movie import *  except:
       print "no echo_language"
       class ECHO_language:
           """ leere Klasse"""
           pass
   
 #regexp for extracting elements from xml  from ECHO_movie import *
 patternTXT=r"<\s*txt.*?>(.*?)</txt>"  import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
 regexpTXT = re.compile(patternTXT, re.IGNORECASE + re.DOTALL)  import xmlrpclib
 patternPage=r"<\s*page.*?>(.*?)</page>"  
 regexpPage = re.compile(patternPage, re.IGNORECASE + re.DOTALL)  
   
   import logging
                   
   #ersetzt logging.info
   def logger(txt,method,txt2):
       """logging"""
       logging.info(txt+ txt2)
   
   def normalizeCt(str):
           """normalizes content_type"""
           #str= str.replace(" ","_")
           return str.replace("-"," ").lower()
   
 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 87  def setECHO_collectionInformation(self,t Line 106  def setECHO_collectionInformation(self,t
         self.credits=toList(credits)          self.credits=toList(credits)
         self.weight=weight          self.weight=weight
   
   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 96  class ECHO_locale(ZopePageTemplate): Line 199  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 115  class ECHO_locale(ZopePageTemplate): Line 221  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 204  class ECHO_layoutTemplate(ZopePageTempla Line 312  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 261  class ECHO_fullText(ZopePageTemplate,ECH Line 371  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().encode('latin-1'))
         pages=dom.getElementsByTagName('page')          pages=dom.getElementsByTagName('page')
                   
         return pages[int(nr)-1].toxml()          return pages[int(nr)-1].toxml()
Line 302  def manage_addECHO_fullText(self, id, ti Line 415  def manage_addECHO_fullText(self, id, ti
     return ''      return ''
   
   
 class ECHO_resource(Folder,Persistent,ECHO_basis):  class ECHO_resource(CatalogAware,Folder,Persistent,ECHO_basis):
     """ECHO Ressource"""      """ECHO Ressource"""
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='ECHO_resource'      meta_type='ECHO_resource'
       default_catalog='resourceCatalog'
   
 #    viewClassificationList=viewClassificationListMaster  #    viewClassificationList=viewClassificationListMaster
   
       def PrincipiaSearchSource(self):
              """Return cataloguable key for ourselves."""
              return str(self)
   
     getSubCols = ECHO_helpers.getSubCols      getSubCols = ECHO_helpers.getSubCols
   
       def reindex(self):
           """generate fields for indexing and reindex"""
           
           #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')      security.declareProtected('View','createPDF')
     def createPDF(self,RESPONSE=None,local=None,dpi=150):      def createPDF(self,RESPONSE=None,local=None,dpi=150):
Line 401  class ECHO_resource(Folder,Persistent,EC Line 544  class ECHO_resource(Folder,Persistent,EC
         return ret+self.createSubElementRDF(urn=urn)           return ret+self.createSubElementRDF(urn=urn) 
   
       
     def getAccessRightSelectorHTML(self,outlook="select"):      def changeAccessRightForm(self,preselect=None):
         """htmlselector"""          """change the access rights"""
         values=['free','mpiwg']  
                   
         if outlook=="select":          pt=zptFile(self, 'zpt/ChangeECHO_resourceAccessRight.zpt')
             ret="""<select name="%s">"""%self.getId()          return pt(preselect=preselect)
       
       def changeAccessRight(self):
           """changeRights"""
           argv=self.REQUEST.form
           self.setAccessRightXML(argv["%s_xml"%self.getId()])
           self.accessRight=argv["%s_echo"%self.getId()]
            
           self.REQUEST.RESPONSE.redirect('manage_main')
           
       
       def getAccessRightSelectorHTML(self,outlook="select",xmldominant=None,preselect=None):
               """htmlselector, xmldominant= in der regel wird der wert des xmlfiles ausgegeben ausser er existiert nicht"""
               values=['','free','MPIWG']
   
               if preselect:#set all to the preselected
                   ar=(preselect,preselect)
               else:#else set to actual value
                   ar=self.getAccessRightMD()
                   
               if outlook=="select":
                       ret="""<select name="%s_xml">"""%self.getId()
                       ret1="""<select name="%s_echo">"""%self.getId()
             for value in values:              for value in values:
                 if value==self.getAccessRightMD():                              if value==ar[0]:
                     ret+="<option selected>%s</option>"%value                      ret+="<option selected>%s</option>"%value
                 else:                  else:
                     ret+="<option>%s</option>"%value                      ret+="<option>%s</option>"%value
                               
                               if value==ar[1]:
                                       ret1+="<option selected>%s</option>"%value
                               else:
                                       ret1+="<option>%s</option>"%value
                       
                       
                       if not xmldominant:
                           return ret+"</select>",ret1+"</select>"
                       else:
                           if ar[0] is not None:
             return ret+"</select>"              return ret+"</select>"
                           else:
                               return "<p>No xml file (only local selection):"+ret1
   
         else:          else:
             ret=""              ret=""
                       ret1=""
             for value in values:              for value in values:
                                   
                 if value==self.getAccessRightMD():                              if value==ar[0]:
                     ret+="""<input type="radio" name="%s" value="%s" checked>%s"""%(self.getId(),value,value)                                      ret+="""<input type="radio" name="%s_xml" value="%s" checked>%s"""%(self.getId(),value,value)
                               else:
                                       ret+="""<input type="radio" name="%s_xml" value="%s">%s"""%(self.getId(),value,value)
                                       
                               if value==ar[1]:
                                       ret1+="""<input type="radio" name="%s_echo" value="%s" checked>%s"""%(self.getId(),value,value)
                               else:
                                       ret1+="""<input type="radio" name="%s_echo" value="%s">%s"""%(self.getId(),value,value)
   
                       if not xmldominant:                        
                           return ret,ret1
                 else:                  else:
                     ret+="""<input type="radio" name="%s" value="%s">%s"""%(self.getId(),value,value)                          if ar[0]:
             return ret              return ret
                           else:
                               return "<p>No xml file (only local selection)</p>"+ret1
   
   
   
       def copyAccessRightsFromMD(self):
               """kopiere rechte aus den metadaten"""
               self.accessRight=self.getAccessRightMD()[0]
               
               
   
   
           
Line 432  class ECHO_resource(Folder,Persistent,EC Line 629  class ECHO_resource(Folder,Persistent,EC
         url=self.metalink          url=self.metalink
   
         try:          try:
             geturl=""                      urllib.urlopen(url)
             for line in ECHO_helpers.urlopen(url).readlines():                  except:
                 geturl=geturl+line                      logger("ECHO_Resource (getAccessRightMD)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
   
                       return None,getattr(self,'accessRight','')
   
         except:  
             return (None,"Cannot open: "+url)  
   
         try:          try:
             dom=xml.dom.minidom.parseString(geturl)                          dom = NonvalidatingReader.parseUri(url)
             root=dom.getElementsByTagName('resource')[0]  
         except:          except:
             return (None,"Cannot parse: "+url+"<br>"+geturl)                          logger("ECHO_Resource (getAccessRightMD)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
                           return (None,"Cannot parse: "+url+"<br>"+"%s (%s)"%sys.exc_info()[0:2])
   
         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                  accessright=dom.xpath("//meta/access-conditions/access/@type")
                   if accessright:
                       accessright=accessright[0].value
                   if str(accessright)=='institution':
                       tmp=dom.xpath("//meta/access-conditions/access/name")
                       if tmp:
                           accessright=getTextFromNode(tmp[0])
   
     def changeAccessRightMD(self,accessright,RESPONSE=None):                  if not accessright:
         """change the rights"""                      accessright=""
                   
                   return accessright,getattr(self,'accessRight','')             
   
       def changeAccessRightMD(self,accessright,RESPONSE=None):
               """change the rights - not user anymore"""
               #TODO: check if method still needed
         params="accessright=%s"%accessright          params="accessright=%s"%accessright
   
   
         #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()          #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()
   
               tries=0
               for i in range(10):
                       x=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()+'/setAccessRightXML'+urllib.quote('?'+params))).read()
                       if x=="ok":
                              
                               break;
                   
         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:          if RESPONSE is not None:
Line 476  class ECHO_resource(Folder,Persistent,EC Line 680  class ECHO_resource(Folder,Persistent,EC
     def setAccessRightXML(self,accessright):      def setAccessRightXML(self,accessright):
         """set accessright"""          """set accessright"""
         url=self.metalink          url=self.metalink
                   accessrights=['MPIWG','free']#allowes rights
                   
                   if accessright =='':
                       """do nothing"""
                       return ""
                       
   
         try:          try:
             geturl=""              geturl=""
Line 492  class ECHO_resource(Folder,Persistent,EC Line 702  class ECHO_resource(Folder,Persistent,EC
         except:          except:
             return (None,"Cannot parse: "+url+"<br>"+geturl)              return (None,"Cannot parse: "+url+"<br>"+geturl)
   
         metanodes=dom.getElementsByTagName('access-conditions')                  metamains=dom.getElementsByTagName('meta')
                   
                   if not metamains:
                           nodenew=dom.createElement('meta')
                           root.appendChild(nodenew)
                           metamain=nodenew
                   else:
                           metamain=metamains[0]
                   
                   
                   metanodes=metamain.getElementsByTagName('access-conditions')
   
         if not metanodes:          if not metanodes:
             nodenew=dom.createElement('access-conditions')              nodenew=dom.createElement('access-conditions')
             root.appendChild(nodenew)                          metamain.appendChild(nodenew)
             metanode=nodenew              metanode=nodenew
         else:          else:
             metanode=metanodes[0]              metanode=metanodes[0]
   
         accesses=metanode.getElementsByTagName('access')          accesses=metanode.getElementsByTagName('access')
   
         if not accesses:                  #delete old
                   if accesses:
                        metanode.removeChild(accesses[0]).unlink()
   
                   #create new
                       
             nodenew2=dom.createElement('access')              nodenew2=dom.createElement('access')
             metanode.appendChild(nodenew2)              metanode.appendChild(nodenew2)
             metanode2=nodenew2              metanode2=nodenew2
         else:  
             metanode2=accesses[0]  
   
         internal=metanode.getElementsByTagName('internal')                  attribute=metanode2.getAttribute('type')
   
         if internal:                  if accessright=="free":
             metanode2.removeChild(internal[0]).unlink()  
   
         free=metanode.getElementsByTagName('free')                       metanode2.setAttribute('type','free')
                   
         if free:                  elif accessright.upper()=='MPIWG':
             metanode2.removeChild(internal[0]).unlink()                          metanode2.setAttribute('type','institution')
                           nodenew4=dom.createElement('name')
                           metanodetext=dom.createTextNode('MPIWG')
                           nodenew4.appendChild(metanodetext)
                           nodenew2.appendChild(nodenew4)
                   #print dom.toxml().encode('utf-8')
                   string= encodeRPC(dom.toxml().encode('utf-8'))
   
                   #TODO: make server configurable
                   server=xmlrpclib.Server("http://foxridge.mpiwg-berlin.mpg.de/server")
   
         if accessright=='free':                  path=urlparse.urlparse(self.metalink)[2]
             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')                  server.writeMetaDataFile(path,string,"yes")
   
     def setStartPageForm(self):      def setStartPageForm(self):
         """Form for changing the startpage"""          """Form for changing the startpage"""
Line 554  class ECHO_resource(Folder,Persistent,EC Line 775  class ECHO_resource(Folder,Persistent,EC
   
   
         if (not resourcepath) or (not digiliburlprefix) or (not images):          if (not resourcepath) or (not digiliburlprefix) or (not images):
             zLOG.LOG("ECHO (createImageUrl)",zLOG.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())                      logger("ECHO (createImageUrl)",logging.ERROR,"Cannot create ImageUrl for %s"%self.absolute_url())
             return None              return None
         resourcepath=resourcepath.replace('/mpiwg/online','')          resourcepath=resourcepath.replace('/mpiwg/online','')
         if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"          if not digiliburlprefix: digiliburlprefix="http://echo.mpiwg-berlin.mpg.de/zogilib?"
Line 609  class ECHO_resource(Folder,Persistent,EC Line 830  class ECHO_resource(Folder,Persistent,EC
         params="startpage=%s"%startpage          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))          #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()              tries=0
               for i in range(10):
                       x=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()
                       if x=="ok":
                              
                               break;
           
                   
         path=self.metalink          path=self.metalink
Line 639  class ECHO_resource(Folder,Persistent,EC Line 865  class ECHO_resource(Folder,Persistent,EC
             return pt()              return pt()
   
   
       def setLink(self, link=None):
           """change link field"""
           if link is not None:
               self.link = link
               
         
     def getTextToolsField(self,name,default=''):      def getTextToolsField(self,name,default=''):
         """Lese Textoolsfelder aus index.meta im path aus"""          """Lese Textoolsfelder aus index.meta im path aus"""
Line 668  class ECHO_resource(Folder,Persistent,EC Line 899  class ECHO_resource(Folder,Persistent,EC
   
         params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)          params="project=%s&xslt=%s&thumbtemplate=%s&topbar=%s&digiLibTemplate=%s&digiliburlprefix=%s"%(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)
   
               try:
                   tries=0
                   for i in range(10):
                           x=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()
                           if x=="ok":
                   
         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()                              break;
   
               except:
                   logger("ECHO_ressource (changeViewerTemplateSet)", logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])          
                   logger("ECHO_ressource (changeViewerTemplateSet)", logging.ERROR,'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)))
         #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)          #print self.absolute_url()+'/newMetaXML'+urllib.quote'?'+params)
         # hack Pfad auf die Dokumente          # hack Pfad auf die Dokumente
         path=self.metalink          path=self.metalink
Line 679  class ECHO_resource(Folder,Persistent,EC Line 918  class ECHO_resource(Folder,Persistent,EC
   
         path=re.sub('/index.meta','',path)           path=re.sub('/index.meta','',path) 
   
         path=re.sub(self.REQUEST['SERVER_URL'],'',path)              #TODO: direct access to the file system necessary, fix that also xmlrpc to the server where the index file is stored is possible    
         path=re.sub('http://'+self.REQUEST['HTTP_HOST'],'',path)              parsedUrl=urlparse.urlparse(path)
               path=parsedUrl[2]
         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  
   
               try:        
         return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()          return ECHO_helpers.urlopen("http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path).readlines()
               except:
                   logger("ECHO_Resource (changeViewerTemplateSet)", logging.INFO,"%s (%s)"%sys.exc_info()[0:2])
                   logger("ECHO_Resource (changeViewerTemplateSet)", logging.INFO,"http://nausikaa2.rz-berlin.mpg.de:86/cgi-bin/toc/admin/reg.cgi?path=%s"%path)
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
Line 716  class ECHO_resource(Folder,Persistent,EC Line 948  class ECHO_resource(Folder,Persistent,EC
         """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""          """getFullTextXML; gives the FullText as an XML Document, and <error></error> if somthing goes wrong."""
   
         try:          try:
             #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"open %s"%self.metalink)                      #logger("ECHO Fulltext",logging.INFO,"open %s"%self.metalink)
             fh=ECHO_helpers.urlopen(self.metalink)              fh=ECHO_helpers.urlopen(self.metalink)
             #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"opened %s"%self.metalink)                      #logger("ECHO Fulltext",logging.INFO,"opened %s"%self.metalink)
             dom=xml.dom.minidom.parse(fh)              dom=xml.dom.minidom.parse(fh)
             texttools=dom.getElementsByTagName('texttool')              texttools=dom.getElementsByTagName('texttool')
             text=texttools[0].getElementsByTagName('text')              text=texttools[0].getElementsByTagName('text')
             texturl=getText(text[0].childNodes)              texturl=getText(text[0].childNodes)
   
             #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"found %s"%texturl)                      #logger("ECHO Fulltext",logging.INFO,"found %s"%texturl)
                     fh.close()                      fh.close()
             #zLOG.LOG("ECHO Fulltext",zLOG.INFO,"closed fh")                      #logger("ECHO Fulltext",logging.INFO,"closed fh")
             #keine url              #keine url
             if not (texturl.split(":")[0] in ['http','ftp','file']):               if not (texturl.split(":")[0] in ['http','ftp','file']): 
             if not noredirect:              if not noredirect:
Line 736  class ECHO_resource(Folder,Persistent,EC Line 968  class ECHO_resource(Folder,Persistent,EC
   
             if not noredirect:              if not noredirect:
                             self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')                                self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')  
                     zLOG.LOG("ECHO Fulltext",zLOG.INFO,"redirect to:%s"%texturl)                              logger("ECHO Fulltext",logging.INFO,"redirect to:%s"%texturl)
                 self.REQUEST.RESPONSE.redirect(texturl)                  self.REQUEST.RESPONSE.redirect(texturl)
             else:              else:
                 return texturl                  return texturl
Line 830  class ECHO_resource(Folder,Persistent,EC Line 1062  class ECHO_resource(Folder,Persistent,EC
         else:          else:
             return ''              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 getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
Line 870  class ECHO_resource(Folder,Persistent,EC Line 1121  class ECHO_resource(Folder,Persistent,EC
   
     def getContentType(self):      def getContentType(self):
         try:          try:
             return self.contentType                      return normalizeCt(self.contentType)
         except:          except:
             return ""              return ""
   
Line 920  class ECHO_resource(Folder,Persistent,EC Line 1171  class ECHO_resource(Folder,Persistent,EC
         self.contentType=self.bib_type          self.contentType=self.bib_type
         for data in self.metadata:          for data in self.metadata:
             data_neu=re.sub('-','_',data)              data_neu=re.sub('-','_',data)
             self.meta                          self.metaDataHash[data_neu]=getattr(self,data)[0:]
                         DataHash[data_neu]=getattr(self,data)[0:]  
   
           
         pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')          pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
Line 929  class ECHO_resource(Folder,Persistent,EC Line 1179  class ECHO_resource(Folder,Persistent,EC
   
   
           
       def changeViewer(self,newViewer):
           """set newViewer to the url of the new viewer
           only if metalink is set, otherwise it gives false
           """
           
           texterUrl="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Texter?fn=/"
           
           vl,msg=self.checkValidityOfMetaLink()
           
           if not vl: #ungueltiger link, versuche neuen
               newStr=re.match(".*/mpiwg/online/(.*)",self.metalink) # suche pfad hinter /mpiwg/online 
               oldLink=self.metalink
               
               if newStr:
                   self.metalink=texterUrl+newStr.group(1)
                   vl,msg=self.checkValidityOfMetaLink()
               else:
                   logging.error("change Viewer XX(mew Metadatafile) %s"%self.metalink)
                   vl=False
                   
               if not vl: # geht immer noch nicht, dann setzte wieder zurueck
                   self.metaLink=oldLink
               
               logging.info("change Viewer (mew Metadatafile) %s"%self.metalink)
              
           if vl:
               self.newViewer=newViewer
               return vl,msg
           else:
               return vl,msg
       
       def checkValidityOfMetaLink(self):
           """checks if the metalink is valid xml"""
           
           ml=self.metalink
           
           try:
               txt=urllib.urlopen(ml)
   
           except:
               return False,"Cannot open: %s)"%ml
           
           txt.close()        
           try:
               dom = NonvalidatingReader.parseUri(ml)
           except:
               return False, "Connot parse: %s)"%ml
           
           if len(dom.xpath("//texttool"))==0:
               return False, "No texttools: %s)"%ml
               
           return True,""
   
     def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,RESPONSE=None):      def changeECHO_resource_main(self,metalink,link,title,label,description,contentType,renderingType,weight,resourceID,newViewer='',RESPONSE=None):
         """Aenderung der Properties"""          """Aenderung der Properties"""
     self.resourceID=resourceID      self.resourceID=resourceID
     self.title=title      self.title=title
Line 944  class ECHO_resource(Folder,Persistent,EC Line 1246  class ECHO_resource(Folder,Persistent,EC
         self.link=link          self.link=link
         self.metalink=metalink          self.metalink=metalink
                   
           self.newViewer=newViewer
           
           
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
Line 986  class ECHO_resource(Folder,Persistent,EC Line 1291  class ECHO_resource(Folder,Persistent,EC
   
     def changeECHO_resource_metadata_local(self,RESPONSE=None):      def changeECHO_resource_metadata_local(self,RESPONSE=None):
         """change metadata"""          """change metadata"""
         tags=self.findTagsFromMapping(self.contentType)              tags=self.findTagsFromMapping(normalizeCt(self.contentType))
         for field in tags[1]:          for field in tags[1]:
             self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]              self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
                           
Line 997  class ECHO_resource(Folder,Persistent,EC Line 1302  class ECHO_resource(Folder,Persistent,EC
   
     def changeECHO_resource_metadata(self,RESPONSE=None):      def changeECHO_resource_metadata(self,RESPONSE=None):
         """change metadata"""          """change metadata"""
         tags=self.findTagsFromMapping(self.contentType)              tags=self.findTagsFromMapping(normalizeCt(self.contentType))
         self.OSAS_meta={}          self.OSAS_meta={}
         for field in tags[1]:          for field in tags[1]:
             try:              try:
                 self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]                  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)]                  self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
             except:              except:
                 """nothing"""                              logger("ECHO_collection (changeECHO_resource_metadata)",logging.ERROR,"%s (%s)"%sys.exc_info()[0:2])
   
               print self.newMetaXML()
               tries=0
               for i in range(10):
                       x=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 x=="ok":
                              
                               break;
   
         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:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def getMDValue(self,fieldName,empty=None):  
       def getMDValueSimpleSearchField(self):
               """returns value for simple search"""
               
               try:
                   return " ".join([self.getMDValue('title',generic="yes"),
                                self.getMDValue('author',generic="yes"),
                                self.getMDValue('year',generic="yes"),self.getTitle()])
               except:
                   
                   #logger(" ECHO_collection(getMDSimpleSearchField)",logging.INFO," ".join([self.getMDValue('title',generic="yes"),
                    #            self.getMDValue('author',generic="yes"),
                     #           self.getMDValue('year',generic="yes"),'']))
                   return ""
                                
       def getMDValue(self,fieldNameTest,empty=None,generic=None):
               """get md values"""
               #TODO: cache mappinghash
               
               fieldName=None
               if generic:
                   if self.contentType:
                       ct=self.contentType.replace(" ","_").lower()
                       ct=self.contentType.replace("-","_").lower()
                   else:
                       logger("ECHO_collection (getMDValue)", logging.INFO, "no_content type for %s"%self.getId())
                       ct=""
                       
                   #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:          if not empty:
             return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)                             #FIXME: warum gibt es manchmal kein metadatahas
                   try:
                       
                       ret =self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%normalizeCt(self.contentType))
                   except:
                       logger("ECHO (line 1069)",logging.ERROR,"no md hash for %s"%self.getId()) 
                       return ""
                   
         else:          else:
             return self.metaDataHash.get(fieldName,empty)  
                      
                      ret= self.metaDataHash.get(fieldNameTest,empty)
                  
               return unicodify(ret)
   
       getFieldValue=getMDValue #depricated
                   
     def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):      def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
         """new index.meta"""          """new index.meta"""
Line 1028  class ECHO_resource(Folder,Persistent,EC Line 1398  class ECHO_resource(Folder,Persistent,EC
                   
             self.copyIndex_meta2echo_resource()              self.copyIndex_meta2echo_resource()
         try:          try:
   
   
             return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)              return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
         except:          except:
                       #print self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix
   
             return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)              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):      def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
         """schreibe md"""              """return bibliographical metadata as stored in the object"""
                   
         try:          try:
                           
Line 1041  class ECHO_resource(Folder,Persistent,EC Line 1415  class ECHO_resource(Folder,Persistent,EC
         except:          except:
             return "<error> no metadata stored</error>"              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):      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"""          """prints out metadata as stored in the echo environment, format is the index.meta format"""
         self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')          self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
Line 1065  class ECHO_resource(Folder,Persistent,EC Line 1466  class ECHO_resource(Folder,Persistent,EC
     {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},      {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
     {'label':'set/change startpage','action':'setStartPageForm'},      {'label':'set/change startpage','action':'setStartPageForm'},
     {'label':'Copy MD for indexing and search','action':'copySearchFields'},      {'label':'Copy MD for indexing and search','action':'copySearchFields'},
           {'label':'Change AccessRights','action':'changeAccessRightForm'}, 
     )      )
   
   
Line 1102  class ECHO_resource(Folder,Persistent,EC Line 1504  class ECHO_resource(Folder,Persistent,EC
   
           
                   
     def getFieldValue(self,field):  
         """get value"""  
       
         try:  
       
             ret=self.metaDataHash[field]  
             if ret == "":  
                 return None  
             else:  
               
             return ret  
         except:  
             return None  
   
     def getMetaDataHash(self):      def getMetaDataHash(self):
         """md hash"""          """md hash"""
         return self.metaDataHash          return self.metaDataHash
           
     def setFieldValue(self,field,value):      def setFieldValue(self,field,value):
         """get value"""          """get value"""
           #TODO: remove setFieldValue
           
     if not hasattr(self,'metaDataHash'):      if not hasattr(self,'metaDataHash'):
         setattr(self,'metaDataHash',{})          setattr(self,'metaDataHash',{})
     self.metaDataHash[field]=value[0:]      self.metaDataHash[field]=value[0:]
           
   
     def copySearchFields(self):      def copySearchFields(self):
         """copys metadatafields to the object"""          """copys metadatafields to the object"""
         fields=['author','title','year']          fields=['author','title','year']
               
         for field in fields:          for field in fields:
             setattr(self,'MD_'+field,self.getFieldValue(field))                      setattr(self,'MD_'+field,self.getMDValue(field,generic="yes"))
           
   
     def findLabelsFromMapping(self,referenceType):      def findLabelsFromMapping(self,referenceType):
Line 1150  class ECHO_resource(Folder,Persistent,EC Line 1539  class ECHO_resource(Folder,Persistent,EC
     fields=[]      fields=[]
         fieldlist=self.standardMD.fieldList          fieldlist=self.standardMD.fieldList
   
         tags=self.findTagsFromMapping(self.contentType)          tags=self.findTagsFromMapping(normalizeCt(self.contentType))
     self.referencetypes=tags[2]      self.referencetypes=tags[2]
     for referenceTypeF in self.referencetypes:      for referenceTypeF in self.referencetypes:
   
         if referenceTypeF[1].title.lower() == referenceType.lower():                  
                   if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
   
             try:              try:
                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields                  bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
Line 1185  class ECHO_resource(Folder,Persistent,EC Line 1575  class ECHO_resource(Folder,Persistent,EC
           
           
   
       
   
         bibdata={}          bibdata={}
         retdata={}          retdata={}
         fieldlist=self.standardMD.fieldList          fieldlist=self.standardMD.fieldList
Line 1194  class ECHO_resource(Folder,Persistent,EC Line 1582  class ECHO_resource(Folder,Persistent,EC
     for referenceTypeF in temp:      for referenceTypeF in temp:
         #print referenceType          #print referenceType
           
         if referenceTypeF[1].title.lower() == referenceType.lower():                   if normalizeCt(referenceTypeF[1].title) == normalizeCt(referenceType.lower()):
             try:              try:
                 bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields                  bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
                 referenceType=referenceTypeF[1].title                  referenceType=referenceTypeF[1].title
Line 1221  class ECHO_resource(Folder,Persistent,EC Line 1609  class ECHO_resource(Folder,Persistent,EC
                           
             return "ERROR:",error,self.absolute_url()              return "ERROR:",error,self.absolute_url()
                   
         self.contentType=metadict['bib_type'][0:]              self.contentType=normalizeCt(metadict['bib_type'])[0:]
         fields=self.findTagsFromMapping(self.contentType)              fields=self.findTagsFromMapping(normalizeCt(self.contentType))
                   
         #fields=self.findLabelsFromMapping(self.contentType)              #fields=self.findLabelsFromMapping(normalizeCt(self.contentType))
         for field in fields[1]:          for field in fields[1]:
                           
             if self.isDefinedInThisSet(fields,field):              if self.isDefinedInThisSet(fields,field):
Line 1236  class ECHO_resource(Folder,Persistent,EC Line 1624  class ECHO_resource(Folder,Persistent,EC
         if RESPONSE:          if RESPONSE:
             return RESPONSE.redirect('manage_main')              return RESPONSE.redirect('manage_main')
                   
     def ECHO_getResourceMD(self,template="yes",back=None):              return "OK:",self.absolute_url(),normalizeCt(self.contentType)
           
       def ECHO_getResourceMD(self,template="yes",back=None,overwrite="no"):
         """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""          """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
         (metadict, error)=readMetadata(self.metalink)          (metadict, error)=readMetadata(self.metalink)
   
Line 1246  class ECHO_resource(Folder,Persistent,EC Line 1636  class ECHO_resource(Folder,Persistent,EC
         if not error=="": #Fehler beim Auslesen des Metafiles          if not error=="": #Fehler beim Auslesen des Metafiles
         return "ERROR:",error          return "ERROR:",error
           
     if not self.contentType:          if (not self.contentType) or (overwrite=="yes"):
         self.contentType=metadict['bib_type'].lower()                  self.contentType=normalizeCt(normalizeCt(metadict['bib_type']).lower())
                   
     if not (metadict['bib_type'].lower()==self.contentType.lower()):          if not (normalizeCt(metadict['bib_type']).lower()==normalizeCt(self.contentType).lower()):
         self.REQUEST.SESSION['contentStorage']=metadict['bib_type']                  self.REQUEST.SESSION['contentStorage']=normalizeCt(metadict['bib_type'])
         self.REQUEST.SESSION['contentZope']=self.contentType                  self.REQUEST.SESSION['contentZope']=normalizeCt(self.contentType)
   
         return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()          return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
   
     self.REQUEST.SESSION['metadict']=metadict          #self.REQUEST.SESSION['metadict']=metadict
   
           
           
     self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])  
           
           self.REQUEST.SESSION['diffs']=checkDiffs(self,metadict)
   
                   
         if template=="yes":          if template=="yes":
                   #pt=PageTemplateFile(os.path.join(package_home(globals()), 'zpt/ECHO_resourceMD.zpt'),metadict=metadict).__of__(self)
         pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')          pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
         return pt()                  
                   return pt(metadict=metadict)
   
           
   
Line 1296  class ECHO_resource(Folder,Persistent,EC Line 1688  class ECHO_resource(Folder,Persistent,EC
         self.REQUEST.RESPONSE.write(fh)          self.REQUEST.RESPONSE.write(fh)
         self.REQUEST.RESPONSE.close()          self.REQUEST.RESPONSE.close()
         return           return 
               
           if getattr(self,'newViewer',''): #benutze den neuen viewer
               url=self.newViewer+'url='+self.metalink+"&mode=texttool"
               return self.REQUEST.RESPONSE.redirect(url)
               
         return self.REQUEST.RESPONSE.redirect(self.link)          return self.REQUEST.RESPONSE.redirect(self.link)
   
     def startpage_html(self):      def startpage_html(self):
Line 1330  class ECHO_resource(Folder,Persistent,EC Line 1727  class ECHO_resource(Folder,Persistent,EC
   
     def generate_label(self):      def generate_label(self):
         """Erzeugt_standard_Label aus Template"""          """Erzeugt_standard_Label aus Template"""
         pt=getattr(self,"label_template_"+self.contentType.lower())          pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())
   
     self.label=pt()[0:]      self.label=pt()[0:]
         return pt()          return pt()
Line 1339  class ECHO_resource(Folder,Persistent,EC Line 1736  class ECHO_resource(Folder,Persistent,EC
   
     def generate_title(self,RESPONSE=None):      def generate_title(self,RESPONSE=None):
         """Erzeugt_standard_Label aus Template"""          """Erzeugt_standard_Label aus Template"""
         pt=getattr(self,"label_template_"+self.contentType.lower())          pt=getattr(self,"label_template_"+normalizeCt(self.contentType).lower())
   
     self.title=pt()[0:]      self.title=pt()[0:]
           
Line 1373  class ECHO_externalLink(Folder,ECHO_basi Line 1770  class ECHO_externalLink(Folder,ECHO_basi
     security.declarePublic('content_html')      security.declarePublic('content_html')
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
         return 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
           
           
     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 1390  class ECHO_externalLink(Folder,ECHO_basi Line 1794  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 1405  class ECHO_externalLink(Folder,ECHO_basi Line 1811  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'
   
       def setLinkType(self,type):
           """ set linkType """
           self.linkType = type
                           
     manage_options = Folder.manage_options+(      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 1425  class ECHO_externalLink(Folder,ECHO_basi Line 1855  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 1447  class ECHO_link(ECHO_externalLink): Line 1878  class ECHO_link(ECHO_externalLink):
   
     meta_type="ECHO_link"      meta_type="ECHO_link"
           
           manage_options = ECHO_externalLink.manage_options+(
                   {'label':'add links config','action':'ECHO_link_addLinksForm'},
                   )
           
           def ECHO_link_addLinksForm(self):
               """Main configuration"""
           
               pt=zptFile(self, 'zpt/ChangeECHO_link_addLinks.zpt')
               return pt()
       
           def ECHO_link_addLinks(self,addLinks,RESPONSE):
               """add links"""
               self.addLinks=addLinks
               if RESPONSE is not None:
                   RESPONSE.redirect('manage_main')
                   
     def content_html(self):      def content_html(self):
         """template fuer link"""          """template fuer link"""
           
   
         if hasattr(self,"link_template"):          if hasattr(self,"link_template"):
             return ECHO_basis.content_html(self,'link')                          ret=ECHO_basis.content_html(self,'link')
   
                   else:
                           ret=ECHO_basis.content_html(self,'collection')
   
   
                   #return ret
                   return ret
   #            
   #            
   #                try:
   #                    return ret.decode('utf-8')
   #                except:
   #                    try: 
   #                        return ret.decode('latin-1')
   #                    except:
   #                
   #                        return ret
   #        
           def getCopyrightsHTML(self):
               """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:          else:
             return ECHO_basis.content_html(self,'collection')                               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 1470  class ECHO_link(ECHO_externalLink): Line 1999  class ECHO_link(ECHO_externalLink):
          else:           else:
             params={}              params={}
                   
                    if getattr(self,'addLinks','yes')=="yes":
          params['backLink']=self.aq_parent.absolute_url()           params['backLink']=self.aq_parent.absolute_url()
          params['startLink']=splitted[0]+"?"+urllib.urlencode(params)           params['startLink']=splitted[0]+"?"+urllib.urlencode(params)
                   
Line 1484  def manage_addECHO_linkForm(self): Line 2014  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)
   
       getattr(self,id).addLinks='no'
       
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
           
   
 class ECHO_collection(Folder, Persistent, Implicit, Cacheable,ECHO_basis):  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'
       
 #    viewClassificationList=viewClassificationListMaster  #    viewClassificationList=viewClassificationListMaster
     displayTypes=displayTypes      displayTypes=displayTypes
   
     path="/mpiwg/online/permanent/shipbuilding"      path="/mpiwg/online/permanent/shipbuilding"
   
       
       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():
                  fn=tempfile.mkstemp()[1]
                  tf=file(fn,"w")
                  x=zf.read(name)
                  tf.write(x)
                  tf.close()
                  try:
                      self._importObjectFromFile(fn,set_owner=1)
                  except:
                      if not ret:
                          ret=""
                      ret+="Cannot import: %s (Already existing?)<br>"%name
                  os.remove(fn)
           
           if ret:
               return """<html><body>%s</body></html>"""%ret
           if RESPONSE:
               RESPONSE.redirect(self.absolute_url())
           
       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):
           """gibt title und label zurueck"""
           return (getattr(self,'title',''),getattr(self,'label',''))
   
     def localizeObjects(self):      def localizeObjects(self):
         """localize all objects"""          """localize all objects"""
         contents=self.ZopeFind(self,obj_metatypes=['ECHO_externalLink','ECHO_link','ECHO_mapText'])          contents=self.ZopeFind(self,obj_metatypes=['ECHO_externalLink','ECHO_link','ECHO_mapText'])
Line 1513  class ECHO_collection(Folder, Persistent Line 2133  class ECHO_collection(Folder, Persistent
         if not find:          if not find:
         self.manage_addECHO_locale("en",'','')          self.manage_addECHO_locale("en",'','')
         for content in contents:          for content in contents:
   
             if content[1].meta_type in['ECHO_link','ECHO_externalLink']:              if content[1].meta_type in['ECHO_link','ECHO_externalLink']:
   
                 find=content[1].ZopeFind(content[1],obj_metatypes=('ECHO_mapText'))                  find=content[1].ZopeFind(content[1],obj_metatypes=('ECHO_mapText'))
                 if find:                  if find:
                     root=find[0][1]                      root=find[0][1]
Line 1546  class ECHO_collection(Folder, Persistent Line 2168  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 1607  class ECHO_collection(Folder, Persistent Line 2229  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 1615  class ECHO_collection(Folder, Persistent Line 2246  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 1697  class ECHO_collection(Folder, Persistent Line 2332  class ECHO_collection(Folder, Persistent
                 pass                  pass
         return ret          return ret
                 
     def updateCollection(self,RESPONSE=None):      def importCollection(self,path=None,RESPONSE=None):
         """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""          """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
         files=os.listdir(self.path)          
           if path is None:
                   pt=zptFile(self, 'zpt/importCollection.zpt')
                   return pt()
   
           files=os.listdir(path)
     ret=""      ret=""
         for fileName in files:          for fileName in files:
                           
             if fileName:              if fileName:
                   
         tempPath=re.sub("/mpiwg/online","",self.path)                  tempPath=re.sub("/mpiwg/online","",path)
         link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"          link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"
                   
         metalink=self.path+"/"+fileName+"/index.meta"          metalink=self.path+"/"+fileName+"/index.meta"
Line 1728  class ECHO_collection(Folder, Persistent Line 2368  class ECHO_collection(Folder, Persistent
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def updateCollectionMD(self,RESPONSE=None):  
         """updateMD"""  
         files=os.listdir(self.path)  
         for fileName in files:  
             if fileName:  
                 genObj=getattr(self,fileName)  
                 genObj.copyIndex_meta2echo_resource()  
                 genObj.generate_title()  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
   
   
     def changeViewerTemplateSetsForm(self):      def changeViewerTemplateSetsForm(self):
         """change the viewer template set"""          """change the viewer template set"""
         pt=zptFile(self, 'zpt/changeViewerTemplateSet')          pt=zptFile(self, 'zpt/changeViewerTemplateSet')
Line 1776  class ECHO_collection(Folder, Persistent Line 2402  class ECHO_collection(Folder, Persistent
         else:          else:
             return None              return None
   
       def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):
           """changes all ressources to the newViewer"""
           
           resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
           if RESPONSE is not None:
                       RESPONSE.write("<html><body>")
   
           for resource in resources:
               
               done,msg=resource[1].changeViewer(newViewer)
               if done:
                   if RESPONSE is not None:
                       RESPONSE.write("<p>OK: %s"%resource[0])
               else:
                   if RESPONSE is not None:
                       RESPONSE.write("<p><a href='%s'>ERROR: %s (%s)</a>"%(resource[1].absolute_url()+'/ECHO_resource_config_main',resource[0],msg))
                   
   
                   
           if RESPONSE is not None:
                       RESPONSE.write("<p>Done</p></body></html>")
   
     def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):      def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):
         """change the templates"""          """change the templates"""
   
Line 1825  class ECHO_collection(Folder, Persistent Line 2473  class ECHO_collection(Folder, Persistent
             if ret and RESPONSE:              if ret and RESPONSE:
                 RESPONSE.write("ok: %s\n"%txt)                  RESPONSE.write("ok: %s\n"%txt)
                           
             #zLOG.LOG("ECHO (copyTitleToInfoXMLFolder)",zLOG.INFO,txt)                         #logger("ECHO (copyTitleToInfoXMLFolder)",logging.INFO,txt)   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.write("done!\n")              RESPONSE.write("done!\n")
             RESPONSE.close()              RESPONSE.close()
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     def copySearchFields(self,RESPONSE=None):      def copySearchFields(self,RESPONSE=None):
         """copys import metadatafields to the object"""              """copys < metadatafields to the object"""
         resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])              resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
         for resource in resources:          for resource in resources:
   
Line 1851  class ECHO_collection(Folder, Persistent Line 2499  class ECHO_collection(Folder, Persistent
     def reloadMetaDataFromStorage(self,RESPONSE=None):      def reloadMetaDataFromStorage(self,RESPONSE=None):
         """copy metadata from the storage to ECHO"""          """copy metadata from the storage to ECHO"""
   
         return reloadMetaDataFromStorage(self,RESPONSE=None)              return reloadMetaDataFromStorage(self,RESPONSE)
   
           
     def getPartnerCopyright(self,name,sonst="generic"):      def getPartnerCopyright(self,name,sonst="generic"):
Line 1873  class ECHO_collection(Folder, Persistent Line 2521  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 1901  class ECHO_collection(Folder, Persistent Line 2551  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 1983  class ECHO_collection(Folder, Persistent Line 2634  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 2030  class ECHO_collection(Folder, Persistent Line 2686  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 2048  class ECHO_collection(Folder, Persistent Line 2704  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 2057  class ECHO_collection(Folder, Persistent Line 2714  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':'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':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
     {'label':'ImportCollection','action':'updateCollection'},          {'label':'ImportCollection','action':'importCollection'},
     {'label':'Copy MD for indexing and search','action':'copySearchFields'},      {'label':'Copy MD for indexing and search','action':'copySearchFields'},
           {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},
         )          )
   
           
Line 2090  class ECHO_collection(Folder, Persistent Line 2749  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 2101  class ECHO_collection(Folder, Persistent Line 2760  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 2158  class ECHO_collection(Folder, Persistent Line 2818  class ECHO_collection(Folder, Persistent
     def content_html(self,**argv):      def content_html(self,**argv):
         """template fuer content"""          """template fuer content"""
     #print "NN",argv      #print "NN",argv
         return ECHO_basis.content_html(self,'collection')          ret = ECHO_basis.content_html(self,'collection')
           
           if type(ret) is StringType:
                  return ret.decode('utf-8')
           else:
                  return ret
           
           
     def getCredits(self):      def getCredits(self):
         """Ausgabe der credits"""          """Ausgabe der credits"""
Line 2195  class ECHO_collection(Folder, Persistent Line 2861  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 2218  class ECHO_collection(Folder, Persistent Line 2886  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 2226  def manage_addECHO_collectionForm(self): Line 2900  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 2515  class ECHO_root(Folder,Persistent,Implic Line 3189  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':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
                   {'label':'Change Weights','action':'changeWeights'},
                   {'label':'Generate from RDF','action':'generateFromRDFForm'},
                   {'label':'update Resource Catalog','action':'updateResourceCatalog'},
                   {'label':'Copy MD for indexing and search','action':'copySearchFields'},
   )
   
   
       def copySearchFields(self,RESPONSE=None):
               """copys < metadatafields to the object"""
               resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)
   
               for resource in resources:
   
     def printer(self,txt):                      resource[1].copySearchFields()
         print txt  
         print txt[2]              if RESPONSE is not None:
         print txt[2].getImageTag()                      RESPONSE.redirect('manage_main')
         print "HO"     
         return txt[2].getImageTag()      def mod_re_sub(self,pattern,replace,string):
           """re.sub aus mod re zur Verfuegung stellen"""
           return re.sub(pattern,replace,string)
       
       def findObjectFromFulltext(self,existUri):
           '''
   
     def printer2(self,txt):          @param url:
         print txt          @param existUri:
           '''
   
           if existUri:
               #TODO: at the moment assume that the filename is unique, the whole has to changed to a system of ids.
               filename=existUri.split("/")[-1]
           
           founds=self.resourceCatalog.search({'fullTextUrl':os.path.splitext(filename)[0]})  
           
           ret=[(found.title,found.getObject().absolute_url(),found.getObject().aq_parent.absolute_url()) for found in founds]
           
           return ret
           
       def reindex(self,RESPONSE=None):
           """indiziere alle Objecte neu"""
           
           if RESPONSE:
               RESPONSE.write("<html><body>")
           
           resources=self.ZopeFind(self,obj_metatypes=["ECHO_resource"], search_sub=1)
           
           for resource in resources:
               resource[1].reindex()
               #print "<p> done %s </p>\n"
               if RESPONSE:
                   RESPONSE.write("<p> done %s </p>\n"%resource[0])
                   
           if RESPONSE:
               RESPONSE.write("<p> ok </p></html></body>\n")
   
     def item2(self,txt):  
         return txt[2]  
   
     def setLanguage(self,lang):      def setLanguage(self,lang):
         """Set language cookie"""          """Set language cookie"""
         self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="")              self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")
   
     def switchLanguage(self):      def switchLanguage(self):
         """Set language cookie"""          """Set language cookie"""
Line 2541  class ECHO_root(Folder,Persistent,Implic Line 3264  class ECHO_root(Folder,Persistent,Implic
         else:          else:
             lang="en"              lang="en"
                   
         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 2732  class ECHO_root(Folder,Persistent,Implic Line 3456  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):      def reloadMetaDataFromStorageWarning(self,RESPONSE=None):
Line 2798  class ECHO_root(Folder,Persistent,Implic Line 3512  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')
Line 3039  class ECHO_root(Folder,Persistent,Implic Line 3753  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 3051  class ECHO_root(Folder,Persistent,Implic Line 3768  class ECHO_root(Folder,Persistent,Implic
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)                  retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
             str=retStr              str=retStr
         if str:          if str:
             return re.sub(r"[\n]","<br/>",str)              str = re.sub(r"[\n]","<br/>",str)
         else:              return unicodify(str)
             return ""  
           
     def link2html(self,str):  
         """link2html fuer VLP muss hier noch raus"""  
         if str:  
   
             str=re.sub("\&","&amp;",str)  
             dom=xml.dom.minidom.parseString("<?xml version='1.0' encoding='utf-8'?><txt>"+str+"</txt>")  
             links=dom.getElementsByTagName("link")  
               
   
             for link in links:  
                 link.tagName="a"  
         ref=link.getAttribute("ref")  
         pn=link.getAttribute("page")  
               
                 if self.checkRef(ref):  
             if pn:  
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref+"&page="+pn)  
             else:  
                 link.setAttribute("href",self.aq_parent.absolute_url()+"/references?id="+ref)  
   
   
             newxml=dom.toxml('utf-8')  
         
         retStr=regexpTXT.search(newxml)  
   
         return retStr.group(1)  
   
                  
         return ""  
   
     def xml2html(self,str,quote="yes"):  
         """link2html fuer VLP muss hier noch raus"""  
   
         if str:  
             if quote=="yes2":  
                 str=re.sub("\&","&amp;",str)  
             #dom=xml.dom.minidom.parseString(str)  
         dom = NonvalidatingReader.parseString(str,"http://www.mpiwg-berlin.mpg.de/")  
             #links=dom.getElementsByTagName("link")  
             links=Ft.Xml.XPath.Evaluate(".//link", contextNode=dom)  
             for link in links:  
                 #link.tagName="a"  
       
                 ref=link.getAttributeNS(EMPTY_NAMESPACE,"ref")  
         pn=link.getAttributeNS(EMPTY_NAMESPACE,"page")  
   
         cns=link.childNodes[0:]  
           
         newLink=dom.createElementNS(EMPTY_NAMESPACE,"a")  
         for x in cns:  
             newLink.appendChild(x)  
           
               
           
         link.parentNode.replaceChild(newLink,link)  
                 if self.checkRef(ref):  
             if pn:  
                 newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref+"&p="+pn)  
             else:              else:
                 newLink.setAttributeNS(EMPTY_NAMESPACE,"href",self.aq_parent.absolute_url()+"/vlp_coll?id="+ref)              return u""
   
             #str= dom.toxml('utf-8')  
         buf = cStringIO.StringIO()  
         PrettyPrint(dom, stream=buf)  
         str = buf.getvalue()  
         buf.close()  
         #str=PrettyPrint(dom.documentElement,encoding='UTF-8')  
         #print link.toxml('utf-8')  
         #print type(str)  
         retStr=regexpPage.search(str)  
           
         try: # hack warum fehtl manchmal page??  
             return retStr.group(1)  
         except:  
             return str  
         return ""  
   
     def checkRef(self,ref):  
         if ref[0:3]=='lit':  
             if len(self.library_data({ 'id':ref}))>0:  
                 return 1  
         try:  
             if ref[0:7]=="tec_cat":  
                 return 1  
         except:  
             """nothing"""  
                           
         dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''}      link2html=vlp_xmlhelpers.link2html
         res=None      related2html=vlp_xmlhelpers.related2html
         for db in dbs.keys():  
             res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))  
         return res  
                                                                           
     #Ende Methode fuer vlp      xml2html=vlp_xmlhelpers.xml2html
    
       checkRef=vlp_xmlhelpers.checkRef
       
   #    def checkRef(self,ref):
   #            if ref[0:3]=='lit':
   #                    if len(self.library_data({ 'id':ref}))>0:
   #                            return 1
   #            try:
   #                    if ref[0:7]=="tec_cat":
   #                            return 1
   #            except:
   #                    """nothing"""
   #                    
   #            dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''}
   #            res=None
   #            for db in dbs.keys():
   #                    res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))
   #            return res
   #                                    
   #    #Ende Methode fuer vlp
   
     def PgQuoteString(self,string):      def PgQuoteString(self,string):
         """Quote string"""          """Quote string"""
Line 3159  class ECHO_root(Folder,Persistent,Implic Line 3807  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 3342  class ECHO_root(Folder,Persistent,Implic Line 3993  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 3404  def manage_addECHO_copyrightType(self,id Line 4094  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 3524  class ECHO_linkList(ZopePageTemplate,ECH Line 4131  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 3535  class ECHO_linkList(ZopePageTemplate,ECH Line 4142  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 3635  def manage_addECHO_support(self, id,inst Line 4244  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 3755  def repairCoords(self): Line 4477  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':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
           {'label':'Change Weights','action':'changeWeights'},
           {'label':'Generate from RDF','action':'generateFromRDFForm'},
           {'label':'update Resource Catalog','action':'updateResourceCatalog'},
           {'label':'Copy MD for indexing and search','action':'copySearchFields'},
           )
   
       
   def manage_addECHO_mainForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)
       return pt()
   
   def manage_addECHO_main(self,id,title,RESPONSE=None):
       """Add an ECHO_main"""
       self._setObject(id,ECHO_main(id,title))
       
       obj=self._getOb(id)
       text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()
       
       manage_addPageTemplate(obj,'main_template',text=text)               
       
     
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
Removed from v.1.234  
changed lines
  Added in v.1.294

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