[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.300 and 1.310.2.11

version 1.300, 2008/12/10 13:37:03 version 1.310.2.11, 2013/05/17 06:20:22
Line 1 Line 1
 """New version of the product started February, 8th. Without scientific classification, use content-type for further classification."""  """New version of the produc started February, 8th. Without scientific classification, use content-type for further classification."""
 """Echo collection provides the classes for the ECHO content web-site.  """Echo collection provides the classes for the ECHO content web-site.
   
 class ECHO_collection is the basis class for an ECHO collection.  class ECHO_collection is the basis class for an ECHO collection.
Line 9  class ECHO_externalLink contains informa Line 9  class ECHO_externalLink contains informa
   
   
 """  """
 try:  
         from reportlab.pdfgen import canvas  
         from reportlab.lib.pagesizes import A4  
 except:  
         print "PDF generation will not work"  
             
 import urlparse  import urlparse
 import string  import string
Line 40  from Globals import Persistent, package_ Line 36  from Globals import Persistent, package_
 from Acquisition import Implicit  from Acquisition import Implicit
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
 from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon  from Products.ZCTextIndex.ZCTextIndex import manage_addLexicon
   import ECHO_helpers
   from Acquisition import aq_parent
   try:
 from Products.MetaDataProvider.MetaDataClient import MetaDataClient  from Products.MetaDataProvider.MetaDataClient import MetaDataClient
   except:
       print "no metadataclient"
 import urllib  import urllib
 import urllib2  import urllib2
 import cgi  import cgi
 import smtplib  import smtplib
 import time  import time
 from Ft.Xml.Domlette import NonvalidatingReader  #from Ft.Xml.Domlette import NonvalidatingReader
 from Ft.Xml.Domlette import PrettyPrint, Print  #from Ft.Xml.Domlette import PrettyPrint, Print
 from Ft.Xml import EMPTY_NAMESPACE  #from Ft.Xml import EMPTY_NAMESPACE
   #
 import Ft.Xml.XPath  #import Ft.Xml.XPath
 import cStringIO  import cStringIO
   
 import sys  import sys
   import logging
   
 try:  try:
         from psycopg import libpq          from psycopg import libpq
Line 79  except: Line 81  except:
         pass          pass
   
 from ECHO_movie import *  from ECHO_movie import *
 import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen  #import vlp_xmlhelpers #TODO: vlp elemente aus echo herausnehmen
 import xmlrpclib  import xmlrpclib
   
 import logging  import logging
   
   from ECHO_root  import ECHO_root
   
 #ersetzt logging.info  #ersetzt logging.info
 def logger(txt,method,txt2):  def logger(txt,method,txt2):
     """logging"""      """logging"""
Line 103  def setECHO_collectionInformation(self,t Line 107  def setECHO_collectionInformation(self,t
         self.weight=weight          self.weight=weight
   
 import ECHO_resource  import ECHO_resource
   from ECHO_resource import manage_addECHO_resource
   
 class ECHO_resource(ECHO_resource.ECHO_resource):  class ECHO_resource(ECHO_resource.ECHO_resource):
     """depricated use class in ECHO_resource.py"""      """depricated use class in ECHO_resource.py"""
Line 376  class ECHO_fullText(ZopePageTemplate,ECH Line 381  class ECHO_fullText(ZopePageTemplate,ECH
                 try:                  try:
                    dom=xml.dom.minidom.parseString(self())                     dom=xml.dom.minidom.parseString(self())
                 except:                  except:
                    dom=xml.dom.minidom.parseString(self().encode('latin-1'))                     dom=xml.dom.minidom.parseString(self.utf8ify(self()))
                 pages=dom.getElementsByTagName('page')                  pages=dom.getElementsByTagName('page')
                                   
                 return pages[int(nr)-1].toxml()                  return pages[int(nr)-1].toxml()
Line 539  class ECHO_link(ECHO_externalLink): Line 544  class ECHO_link(ECHO_externalLink):
                 {'label':'add links config','action':'ECHO_link_addLinksForm'},                  {'label':'add links config','action':'ECHO_link_addLinksForm'},
                 )                  )
                   
           def getMDValueSimpleSearchField(self):
             """returns value for simple search"""
             return " ".join([self.getTitle(),self.getDescription()])
        
         def ECHO_link_addLinksForm(self):          def ECHO_link_addLinksForm(self):
             """Main configuration"""              """Main configuration"""
                   
Line 692  class ECHO_collection(CatalogAware, Fold Line 701  class ECHO_collection(CatalogAware, Fold
     meta_type='ECHO_collection'      meta_type='ECHO_collection'
     default_catalog='resourceCatalog'      default_catalog='resourceCatalog'
           
       rootMetaTypes = ['ECHO_root', 'ECHO_main', 'ECHO_nav']
       
 #    viewClassificationList=viewClassificationListMaster  #    viewClassificationList=viewClassificationListMaster
     displayTypes=displayTypes      displayTypes=displayTypes
   
     path="/mpiwg/online/permanent/shipbuilding"      path="/mpiwg/online/permanent/shipbuilding"
   
       def getSection(self, crumbs=None):
           """returns the current section name"""
           # use breadcrumbs if available
           if crumbs is not None and len(crumbs) > 0:
               return crumbs[0][2].getId()
       
           p = self
           sec = None
           # descend parents to the root (and remember the last id)
           while p is not None and p.meta_type not in self.rootMetaTypes:
               sec = p.getId()
               p = aq_parent(p.context)
        
           return sec
       
       def getSubSection(self, crumbs=None):
           """returns the current subsection name"""
           # use breadcrumbs if available
           if crumbs is not None and len(crumbs) > 1:
               return crumbs[1][2].getId()
       
           p = self
           sec = None
           subsec = None
           # descend parents to the root (and remember the last id)
           while p is not None and p.meta_type not in self.rootMetaTypes:
               subsec = sec
               sec = p.getId()
               p = aq_parent(p.context)
             
           return subsec
       
       
       def getCrumb(self):
           """returns breadcrumb for this object"""
           return ECHO_helpers.getCrumb(self)
   
       def getHierCrumbs(self):
           """returns a list of hierarchical breadcrumbs from self to the ECHO_root"""
           return ECHO_helpers.getHierCrumbs(self)
   
           
     def exportImportObjects_html(self,RESPONSE):      def exportImportObjects_html(self,RESPONSE):
         """ImportObject"""          """ImportObject"""
Line 718  class ECHO_collection(CatalogAware, Fold Line 770  class ECHO_collection(CatalogAware, Fold
         ret=None          ret=None
                   
         for name in zf.namelist():          for name in zf.namelist():
                fn=tempfile.mkstemp()[1]                 ds,fn=tempfile.mkstemp()
                tf=file(fn,"w")                 tf=file(fn,"w")
                x=zf.read(name)                 x=zf.read(name)
                tf.write(x)                 tf.write(x)
Line 729  class ECHO_collection(CatalogAware, Fold Line 781  class ECHO_collection(CatalogAware, Fold
                    if not ret:                     if not ret:
                        ret=""                         ret=""
                    ret+="Cannot import: %s (Already existing?)<br>"%name                     ret+="Cannot import: %s (Already existing?)<br>"%name
              os.close(ds)
                os.remove(fn)                 os.remove(fn)
                   
           zf.close()
   
         if ret:          if ret:
             return """<html><body>%s</body></html>"""%ret              return """<html><body>%s</body></html>"""%ret
         if RESPONSE:          if RESPONSE:
Line 849  class ECHO_collection(CatalogAware, Fold Line 904  class ECHO_collection(CatalogAware, Fold
             if not urn:              if not urn:
                     urn=self.absolute_url()                      urn=self.absolute_url()
                                           
             li="""<RDF:li RDF:resource="%s" />\n"""              li="""<rdf:li rdf:resource="%s" />\n"""
   
                           
             for content in contents:              for content in contents:
           try:
                     ret+=content[1].getRDF()+"\n"                      ret+=content[1].getRDF()+"\n"
                                       except:
             ret+="""<RDF:Seq RDF:about="%s">\n"""%urn              logging.error("getrdf: "+repr(content[1].getRDF()))
               try:
                   ret+=self.unicodify(content[1].getRDF())+"\n"
               except:
               logging.error("--still cannot do it")
                   ret+=repr(content[1].getRDF())+"\n"
               ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
             for content in contents:              for content in contents:
                     nurn=content[1].absolute_url()                      nurn=content[1].absolute_url()
                     ret+=li%nurn                      ret+=li%nurn
             return ret+"</RDF:Seq>"              return ret+"</rdf:Seq>"
               
   
       def getExportAsJSON(self,REQUEST=None):
           import json
           ret = self.getExport()
           
           if REQUEST:
                   REQUEST.response.setHeader("Content-type", "text/json; charset=utf-8")
            
           return json.dumps(ret)
       
       def getExport(self,REQUEST=None):
           
               """JSON export collection content"""
               import json
               ret={}
               #contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
               contents=self.ZopeFind(self,obj_metatypes=['ECHO_resource'])
   
               ret['description']=self.getDescription();
               ret['title']=self.getTitle();
               ret['label']=self.getLabel();
               ret['content']=[]
               ret['echo_path']=self.absolute_url().replace(self.echo_pages.absolute_url(),'')
               
               
               for content in contents:
                  
                   ret['content'].append(content[1].getDRI(type="mpiwg"))
               
               return ret
               
               
               
                           
   
           
Line 989  class ECHO_collection(CatalogAware, Fold Line 1085  class ECHO_collection(CatalogAware, Fold
                             pass                              pass
             return ret              return ret
                 
     def importCollection(self,path=None,RESPONSE=None):      def importCollection(self,path=None,viewerUrl=None,metaDataUrl=None,replacePathPermanent=None,replacePathExperimental=None,RESPONSE=None):
         """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""          """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
                   
         if path is None:          if path is None:
Line 1002  class ECHO_collection(CatalogAware, Fold Line 1098  class ECHO_collection(CatalogAware, Fold
                           
             if fileName:              if fileName:
                                   
                 tempPath=re.sub("/mpiwg/online","",path)                  if (replacePathExperimental and replacePathExperimental!=''):
                 link="http://echo.mpiwg-berlin.mpg.de/zogilib_book?fn="+tempPath+"/"+fileName+"/pageimg"                      path=re.sub(replacePathExperimental,"/mpiwg/online/experimental",path)
                      
                   if (replacePathPermanent and replacePathPermanent!=''):
                       path=re.sub(replacePathPermanent,"/mpiwg/online/permanent",path)
                  
                   link=viewerUrl%(path+"/"+fileName+"/pageimg")
                                   
                 metalink=self.path+"/"+fileName+"/index.meta"                  metalink=metaDataUrl+"/"+path+"/"+fileName+"/index.meta"
                 try:                  try:
   
                         #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"                          #link="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/toc/toc.x.cgi?dir="+fileName+"&step=thumb"
                                                   
                         newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'generated','book','','','','','','')                          newObj=ECHO_resource(fileName,link,metalink,fileName,fileName,fileName,'','book','','','','','','')
                         self._setObject(fileName,newObj)                          self._setObject(fileName,newObj)
                                   
                         genObj=getattr(self,fileName)                          genObj=getattr(self,fileName)
Line 1025  class ECHO_collection(CatalogAware, Fold Line 1126  class ECHO_collection(CatalogAware, Fold
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def changeViewerTemplateSetsForm(self):  
       def changeViewerForm(self):
             """change the viewer template set"""              """change the viewer template set"""
             pt=zptFile(self, 'zpt/changeViewerTemplateSet')              pt=zptFile(self, 'zpt/changeECHOViewer')
             return pt()              return pt()
   
     def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):  
             """Get the ViewerTemplateSet title for configuration"""  
             ret=[]  
               
             try:  
                     viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.  
               
                     for viewerTemplateSet in viewerTemplateSets:  
                             ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))  
   
                     return ret  
                       
             except:  
                     return [('no ViewerTemplateSetfolders','')]  
   
     def getTextToolsField(self,name,default=''):      def getTextToolsField(self,name,default=''):
             """Lese viewerTemplateSet der Collection not implemented yet!"""              """Lese text tool field  der Collection not implemented yet!"""
                           
             return default              return default
   
                           
     def isSelectedViewerTemplateSet(self,obj,id):  
         """is ausgewaehlt"""  
           
         if self.REQUEST['viewerTemplateSet']==id:  
             return 1  
         else:  
             return None  
   
     def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):      def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):
         """changes all ressources to the newViewer"""          """changes all ressources to the newViewer"""
Line 1081  class ECHO_collection(CatalogAware, Fold Line 1161  class ECHO_collection(CatalogAware, Fold
         if RESPONSE is not None:          if RESPONSE is not None:
                     RESPONSE.write("<p>Done</p></body></html>")                      RESPONSE.write("<p>Done</p></body></html>")
   
     def changeViewerTemplateSets(self,project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix,RESPONSE=None):  
             """change the templates"""  
   
             resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)  
   
             for resource in resources:  
   
                     resource[1].changeViewerTemplateSet(project,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix)  
   
             if RESPONSE is not None:  
                     RESPONSE.redirect('manage_main')  
   
   
     def setStartpageFolderForm(self):  
             """Form for changing the startpage"""  
   
               
             pt=zptFile(self, 'zpt/ChangeECHO_resourceStartPageFolder.zpt')  
             pt.content_type="text/html"  
             return pt()  
       
     def setStartpageFolder(self,startpage=None,RESPONSE=None):  
             """change the templates"""  
   
             resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)  
   
             for resource in resources:  
   
                     resource[1].setStartPage(startpage)  
   
             if RESPONSE is not None:  
                     RESPONSE.redirect('manage_main')  
   
     def copyTitleToInfoXMLFolder(self,RESPONSE=None):      def copyTitleToInfoXMLFolder(self,RESPONSE=None):
             """copy title into the title field of info.xml              """copy title into the title field of info.xml
Line 1147  class ECHO_collection(CatalogAware, Fold Line 1196  class ECHO_collection(CatalogAware, Fold
             if RESPONSE is not None:              if RESPONSE is not None:
                     RESPONSE.redirect('manage_main')                      RESPONSE.redirect('manage_main')
                                           
     def reloadMetaDataFromStorageWarning(self,RESPONSE=None):  
             """warning"""  
             pt=zptFile(self, 'zpt/reloadMetaDataFromStorageWarning.zpt')  
             pt.content_type="text/html"  
             return pt()  
   
     def reloadMetaDataFromStorage(self,RESPONSE=None):  
             """copy metadata from the storage to ECHO"""  
   
             return reloadMetaDataFromStorage(self,RESPONSE)  
   
           
     def getPartnerCopyright(self,name,sonst="generic"):      def getPartnerCopyright(self,name,sonst="generic"):
Line 1390  class ECHO_collection(CatalogAware, Fold Line 1429  class ECHO_collection(CatalogAware, Fold
         {'label':'Export/Import Objects','action':'exportImportObjects_html'},          {'label':'Export/Import Objects','action':'exportImportObjects_html'},
         {'label':'Graphic Coords','action':'ECHO_graphicEntry'},          {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},          {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
         {'label':'Set Startpage','action':'setStartpageFolderForm'},          {'label':'Change Image Viewer','action':'changeViewerForm'},
         {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},  
         {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},  
         {'label':'ImportCollection','action':'importCollection'},          {'label':'ImportCollection','action':'importCollection'},
         {'label':'Copy MD for indexing and search','action':'copySearchFields'},  
         {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},          {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},
         )          )
   
Line 1409  class ECHO_collection(CatalogAware, Fold Line 1445  class ECHO_collection(CatalogAware, Fold
         if not hasattr(self,'sortfield'):          if not hasattr(self,'sortfield'):
             self.sortfield="weight"              self.sortfield="weight"
       
         pt=zptFile(self, 'zpt/ChangeECHO_collection.zpt')          pt=zptFile(self, 'zpt/ChangeECHO_Collection.zpt')
         return pt()          return pt()
   
   
Line 1453  class ECHO_collection(CatalogAware, Fold Line 1489  class ECHO_collection(CatalogAware, Fold
           
     def showOverview(self):      def showOverview(self):
         """overview"""          """overview"""
         if 'ECHO_overview.html' in self.__dict__.keys():          # use ECHO_overview.html template in this instance
             return getattr(self,'ECHO_overview.html')()          if 'ECHO_overview.html' in self:
               return self['ECHO_overview.html']()
           
           # use ECHO_overview_main template in path
           if hasattr(self, 'ECHO_overview_main'):
               return getattr(self, 'ECHO_overview_main')()
           
           # use template from Product
         pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')          pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')
         return pt()          return pt()
   
Line 1463  class ECHO_collection(CatalogAware, Fold Line 1506  class ECHO_collection(CatalogAware, Fold
     def index_html(self):      def index_html(self):
         """standard page"""          """standard page"""
         if self.ZCacheable_isCachingEnabled():          if self.ZCacheable_isCachingEnabled():
               
             result = self.ZCacheable_get()              result = self.ZCacheable_get()
             if result is not None:              if result is not None:
                 # Got a cached value.                  # Got a cached value.
                 return result                  return result
                   
         if 'index.html' in self.__dict__.keys():          # old Zope 2.9 method
             ret=getattr(self,'index.html')()          #if 'index.html' in self.__dict__.keys():
           #    ret=getattr(self,'index.html')()
   
           # use Zope 2.12 IContainer for child access
           if 'index.html' in self:
               # use index.html template if it exists
               ret = self['index.html']()
                   
         elif 'overview' in self.__dict__.keys():          elif 'overview' in self:
               # use red-rectangle template when there's an 'overview'
             ret=self.showOverview()              ret=self.showOverview()
   
           # use getattr for acquisition
         elif hasattr(self,'collection_index_template'):          elif hasattr(self,'collection_index_template'):
               # use 'collection_index_template' in acquisition path
             ret=self.collection_index_template()                  ret=self.collection_index_template()    
         elif hasattr(self,'main_index_template'):  
   
           elif hasattr(self,'main_index_template'):
               # use 'main_index_template' in acquisition path
             ret=self.main_index_template.__of__(self)(self.main_template)              ret=self.main_index_template.__of__(self)(self.main_template)
               
         else:          else:
               # use template from Product
             pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')              pt=zptFile(self, 'zpt/ECHO_main_index_template_standard.zpt')
             pt.content_type="text/html"              pt.content_type="text/html"
             ret=pt.render()              ret=pt.render()
Line 1508  class ECHO_collection(CatalogAware, Fold Line 1563  class ECHO_collection(CatalogAware, Fold
   
     def area_img(self):      def area_img(self):
         """area image"""          """area image"""
         bt = BrowserCheck(self)          bt = browserType(self)
         if bt.isIE or bt.isN4:          if bt['isIE'] or bt['isN4']:
             return sendFile(self, 'images/red.gif', 'image/gif')              return sendFile(self, 'images/red.gif', 'image/gif')
         else:          else:
             return sendFile(self, 'images/reda.png', 'image/png')              return sendFile(self, 'images/reda.png', 'image/png')
Line 1607  class ECHO_group(ECHO_collection): Line 1662  class ECHO_group(ECHO_collection):
                           
             if not urn:              if not urn:
                     urn=self.absolute_url()                      urn=self.absolute_url()
             li="""<RDF:li RDF:resource="%s" />\n"""              li="""<rdf:li rdf:resource="%s" />\n"""
                           
                           
             for content in contents:              for content in contents:
                     ret+=content[1].getRDF()+"\n"                      ret+=self.unicodify(content[1].getRDF())+"\n"
                                           
             ret+="""<RDF:Seq RDF:about="%s">\n"""%urn              ret+="""<rdf:Seq rdf:about="%s">\n"""%urn
             for content in contents:              for content in contents:
                     nurn=content[1].absolute_url()                      nurn=content[1].absolute_url()
                     ret+=li%nurn                      ret+=li%nurn
             return ret+"</RDF:Seq>"              return ret+"</rdf:Seq>"
                           
         def index_html(self):          def index_html(self):
                 """standard page"""                  """standard page"""
Line 1801  class ECHO_userFolder(UserFolder): Line 1856  class ECHO_userFolder(UserFolder):
                         return 1                          return 1
             return 0              return 0
   
 Globals.default__class_init__(ECHO_userFolder)  # ROC: problem with 2.12
   #Globals.default__class_init__(ECHO_userFolder)
   
   
   
Line 1856  def createNode(self,descrs,node): Line 1912  def createNode(self,descrs,node):
         return "XX"          return "XX"
   
   
 class ECHO_root(Folder,Persistent,Implicit):  
     """ECHO Root Folder"""  
   
     security=ClassSecurityInfo()  
       
     meta_type="ECHO_root"  
     management_page_charset="utf-8"  
       
     getSubCols = ECHO_helpers.getSubCols  
   
     manage_options=Folder.manage_options+(  
                 {'label':'Main Config','action':'ECHO_copyright_configForm'},  
                 {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},  
                 {'label':'Change Weights','action':'changeWeights'},  
                 {'label':'Generate from RDF','action':'generateFromRDFForm'},  
                 {'label':'update Resource Catalog','action':'updateResourceCatalog'},  
                 {'label':'Copy MD for indexing and search','action':'copySearchFields'},  
 )  
   
   
     def getECHORootURL(self):  
         return self.absolute_url()  
       
     def getECHORoot(self):  
         return self  
       
     def copySearchFields(self,RESPONSE=None):  
             """copys < metadatafields to the object"""  
             resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1)  
   
             for resource in resources:  
   
                     resource[1].copySearchFields()  
   
             if RESPONSE is not None:  
                     RESPONSE.redirect('manage_main')  
      
     def mod_re_sub(self,pattern,replace,string):  
         """re.sub aus mod re zur Verfuegung stellen"""  
         return re.sub(pattern,replace,string)  
       
     def findObjectFromFulltext(self,existUri):  
         '''  
           
         @param url:  
         @param existUri:  
         '''  
   
         if existUri:  
             #TODO: at the moment assume that the filename is unique, the whole has to changed to a system of ids.  
             filename=existUri.split("/")[-1]  
           
         founds=self.resourceCatalog.search({'fullTextUrl':os.path.splitext(filename)[0]})    
           
         ret=[(found.title,found.getObject().absolute_url(),found.getObject().aq_parent.absolute_url()) for found in founds]  
           
         return ret  
           
     def reindex(self,RESPONSE=None):  
         """indiziere alle Objecte neu"""  
           
         if RESPONSE:  
             RESPONSE.write("<html><body>")  
           
         resources=self.ZopeFind(self,obj_metatypes=["ECHO_resource"], search_sub=1)  
           
         for resource in resources:  
             resource[1].reindex()  
             #print "<p> done %s </p>\n"  
             if RESPONSE:  
                 RESPONSE.write("<p> done %s </p>\n"%resource[0])  
                   
         if RESPONSE:  
             RESPONSE.write("<p> ok </p></html></body>\n")  
               
   
     def setLanguage(self,lang):  
             """Set language cookie"""  
             self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")  
   
     def switchLanguage(self):  
             """Set language cookie"""  
             if self.getLanguage()=="en":  
                     lang="de"  
             else:  
                     lang="en"  
               
             self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")  
             self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1'])  
               
     def getLanguage(self):  
             """get language cookie"""  
             lang= self.REQUEST.cookies.get('lang_exhibition','de')  
             if lang == '':  
                     lang="de"  
             return lang  
       
     def getContentOverviewTemplate(self):  
         """produces overview template with macro"""  
         pt = zptObjectOrFile(self, 'content_overview_template')  
         return pt  
   
     def mapstyle_css(self):  
         """send mapstyle.css"""  
         sendFile(self, 'html/ECHO_mapstyle.css', 'text/css')  
   
   
     ###Cdli adds -> have to be removed  
     def getTablet(self,item):  
         #print "getTablet"  
         try:  
                 read=urllib.urlopen("http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"%item).read()  
                 read=re.sub("\[search\]","search",read)  
                 return read[read.find("<body>")+6:read.rfind("</body>")]  
         except:  
                 return "<h1>Sorry no connection to the data server enlil.museum.upenn.edu</h1>"  
         #return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"  
     ###END CDLI add  
   
   
     def URLquote(self, text):  
         """urllib.quote fuer Michael"""  
         return urllib.quote(text)  
   
   
     def checkResource(self,id):  
             """checks if a resource is in the tree, gives back none or list of resources"""  
             if not id:  
                 id=""  
             splitted=id.split("/")  
             id=splitted[len(splitted)-1]  
             if hasattr(self,"_v_checkResource") and self._v_checkResource.has_key(id): #existiert ein cache und id ist bereits drin?  
                             return self._v_checkResource[id]  
   
             else:  
                     resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],obj_ids=[id],search_sub=1)  
   
                     if not hasattr(self,"_v_checkResource"): self._v_checkResource={}#lege cache an falls nicht existent  
                     if resources:  
                             self._v_checkResource[id]=resources[0:] # slicing to be sure that data is stabil  
                     else:  
                             self._v_checkResource[id]=None  
                       
                     return self._v_checkResource[id]  
               
     def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):  
             """sendform"""  
             toaddrs=["dwinter@mpiwg-berlin.mpg.de"]  
               
             msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n"  
                    % (fromaddr, ", ".join(toaddrs),"testsub"))  
             server = smtplib.SMTP(server)  
             #server.set_debuglevel(1)  
             msg=msg+content  
             server.sendmail(fromaddr, toaddrs, msg)  
             server.quit()  
                    
     def generateFromRDFForm(self):  
                 """change form"""  
                 pt=zptFile(self, 'zpt/generateFromRDFForm')  
                 pt.content_type="text/html"  
                 return pt()  
   
     def generateFromRDF(self,file,startNode="/Cuneiform Corpus"):  
   
             """generate from RDF"""  
   
             global seqs  
             seqs={}  
             global descrs  
             descrs={}  
             global key  
             key=""  
             global value  
             value=""  
   
             def getEdges(seqs,urn):  
                     """edges"""  
                     ret=[]  
                     return seqs[urn]  
   
             def createSubs(self,seqs,descrs,urn,level=0):  
                     """create subs"""  
                     for edge in getEdges(seqs,urn):  
                             cn=createNode(self,descrs,edge)  
                             if cn[0]=="CDLI_group":  
                                     createSubs(cn[1],seqs,descrs,cn[2],level+1)  
                     return  
   
             def start_element(name,attrs):  
   
                     global seqs  
                     global descrs  
                     global key  
                     global value  
                     seq=""  
                     if name=="RDF:Seq":  
                             key=attrs.get('RDF:about')  
                             try: # teste ob liste  
                                     x=seqs[key][0]  
                             except:  
   
                                     seqs[key]=[]  
   
                       
                     elif name=="RDF:Description":  
                             key=attrs.get('RDF:about')  
                               
   
                     elif name=="RDF:li":  
                             name=attrs.get('RDF:resource')  
                             seqs[key].append(name)  
   
                     elif name=="ECHONAVIGATION:type":  
                             value="type"  
   
                     elif name=="ECHONAVIGATION:name":  
                             value="name"  
                     elif name=="ECHONAVIGATION:linkClickable":  
                             value="linkClickable"  
                               
             def end_element(name):  
                             """nothing"""  
                             key=""  
                             value=""  
   
             def char_data(data):  
                     """nothing"""  
   
                     data=re.sub("\n","",data)  
                     try:  
                             if descrs[key].has_key(value):  
                                     descrs[key][value]+=data  
                             else:  
                                     descrs[key][value]=data  
                     except:  
   
                             descrs[key]={}  
                             descrs[key][value]=data  
                               
             p = xml.parsers.expat.ParserCreate()  
               
             p.StartElementHandler = start_element  
             p.EndElementHandler = end_element  
             p.CharacterDataHandler = char_data  
               
               
             p.ParseFile(file)  
             self.REQUEST.RESPONSE.write("<html><body><h1>Start</h1>")  
             createSubs(self,seqs,descrs,startNode)  
             self.REQUEST.RESPONSE.write("<h1>done</h1></body></html>")  
             #print "done"  
   
               
             return "done"  
       
               
   
                   
     def changeWeightsInCollection(self):  
             """change all lables of a collection"""  
             ret=""  
             argv=self.REQUEST.form  
               
             resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])  
             for resource in resources:  
                      
                     try:  
                             ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"  
                             resource[1].weight=argv[resource[1].getId()][0:]  
                     except:  
                             pass  
             return ret  
   
     def changeWeights(self):  
                 """change form"""  
                 pt=zptFile(self, 'zpt/changeWeightForm')  
                 pt.content_type="text/html"  
                 return pt()  
     
   
     def reloadMetaDataFromStorageWarning(self,RESPONSE=None):  
             """warning"""  
             pt=zptFile(self, 'zpt/reloadMetaDataFromStorageWarning.zpt')  
             pt.content_type="text/html"  
             return pt()  
   
     def reloadMetaDataFromStorage(self,RESPONSE=None):  
             """reload MD from Storage"""  
   
             return reloadMetaDataFromStorage(self,RESPONSE)  
       
     def getRDF(self,urn=None):  
             """rdf of the collection"""  
   
             contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])  
   
             ret=getRDFDescription(self,self.absolute_url(),urn=urn)  
               
             li="""<RDF:li RDF:resource="%s" />\n"""  
   
               
             for content in contents:  
                     ret+=content[1].getRDF()+"\n"  
                       
             ret+="""<RDF:Seq RDF:about="%s">\n"""%urn  
             for content in contents:  
                     nurn=content[1].absolute_url()  
                     ret+=li%nurn  
             return ret+"</RDF:Seq>"  
               
   
     def showContent(self,path):  
             """return content/html"""  
               
             return ECHO_helpers.urlopen(path+"/content_html").read()  
       
     def getImageViewers(self):  
         """images"""  
         viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])  
         return viewers  
       
   
     def getBibTag(self,tag,content):  
             """get field tag for index-meta-generation"""  
             if not content or content=="":  
                     return ""  
             ret="<%s>"%tag  
             #ret+=urllib.quote(content)  
             ret+=content  
   
             ret+="</%s>"%tag  
             return ret  
   
     def getValueFromClass(self,field,found):  
             """ret attribute if existing"""  
             try:  
                       
                     return getattr(found,field)#.decode('utf-8','ignore')  
             except:  
                     logging.error("can't: decode: %s"%repr(field))  
                     logging.error("      %s %s"%(sys.exc_info()[0],sys.exc_info()[1]))  
                     return ""  
   
     security.declarePublic('getImageTag')  
     def getImageTag(self):  
             """needed by main_template"""  
             return ""  
           
     secondaryLink="" #needed by main_template  
     secondaryLinkTitle="" #needed by main_template  
       
     def getBgcolour(self):  
         """hack"""  
         return "#dddddd"  
   
     security.declareProtected('View','contentTypeSelector_HTML')  
     def contentTypeSelector_HTML(self,selected=None):  
         """give type selector"""  
         if not selected:  
             retStr="<option selected>\n"  
         else:  
             retStr="<option>\n"  
               
         try: # erste version contentTypes exists  
             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):  
                 if selected and (contentType[0]==selected):  
                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])  
                 else:                  
                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])  
         except:  
                 try:  
                         for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):  
                                 if selected and (contentType[0]==selected):  
                                         retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])  
                                 else:                  
                                         retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])  
                 except:  
                         """nothing"""  
                               
         return retStr  
   
     def renderingTypeSelector_HTML(self,selected=None):  
          """give type selector"""  
          if not selected:  
                  retStr="<option selected>\n"  
          else:  
                  retStr="<option>\n"  
                    
          try: # erste version renderingTypes exists  
                  for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):  
                          if selected and (renderingType[0]==selected):  
                                  retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])  
                          else:                  
                                  retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])  
          except:  
                  """nothing"""  
          return retStr  
   
   
     def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):  
          """give type selector"""  
   
          if not first:  
                  if not selected:  
                          retStr="<option selected>\n"  
                  else:  
                          retStr="<option>\n"  
          else:  
                  if not selected:  
                          retStr="""<option selected value="%s">%s\n"""%first  
                  else:  
                          retStr="""<option value="%s">%s\n"""%first  
   
            
          try: # erste version copyrightTypes exists  
                  for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):  
                          if selected and (copyrightType[0]==selected):  
                                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
                          else:                  
                                  retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
                    
                  for copyrightTypeSelf in self.ZopeFind(object,obj_metatypes=["ECHO_copyrightType"],search_sub=1):  
                          if selected and (copyrightTypeSelf[0]==selected):  
                                  retStr+="""<option selected value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])  
                          else:                  
                                  retStr+="""<option value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])  
                                    
          except:  
              """nothing"""  
                    
          return retStr  
   
     def partnerSelector_HTML(self,selected=None):  
          """give type selector"""  
          if not selected:  
                  retStr="<option selected>\n"  
          else:  
                  retStr="<option>\n"  
                    
          try: # erste version copyrightTypes exists  
                  for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):  
                          if selected and (copyrightType[0]==selected):  
                                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
                          else:                  
                                  retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
          except:  
                  """nothing"""  
          return retStr  
    
     mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version ueber echoroot??  
   
     def mediaTypeSelector_HTML(self,selected=None):  
          """give type selector"""  
          if not selected:  
                  retStr="<option selected>\n"  
          else:  
                  retStr="<option>\n"  
            
          try: # erste version mediatypesTypes exists  
                  for mediaType in self.mediaTypes:  
                          if selected and (mediaType in selected):  
                                  retStr+="""<option selected value="%s">%s\n"""%(mediaType,mediaType)  
                          else:                  
                                  retStr+="""<option value="%s">%s\n"""%(mediaType,mediaType)  
          except:  
                  """nothing"""  
          return retStr  
   
               
     def patchContentType(self,obj=None):  
         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""  
       
   
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])  
   
         for entry in entries:  
                 setattr(entry[1],'contentType',entry[1].content_type)  
                 #entry[1].contentType == entry[1].content_type  
   
                 if entry[1].meta_type == 'ECHO_collection':  
                     entry[1].patchContentType(entry[1])      
   
                   
         return "changed all contenttypes in: "+self.title  
   
   
     def repairAllCoords(self):  
         """updates map coordinates on the same and sublevels"""  
         return repairCoords(self)  
   
   
     def patchViewClassification(self,obj=None):  
         """setze viewClassification heuristisch"""  
   
         def checkIfArrow(obj):  
                 if hasattr(obj,'coords'):  
                         for coordtemp in obj.coords:  
   
                                 if (len(coordtemp)>4) and not (coordtemp[4]==''):  
                                         return 4  
                         return None  
                 return None  
           
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])  
   
         for entry in entries:  
                   
                 if checkIfArrow(entry[1]):  
                         setattr(entry[1],'viewClassification','view point')  
                 else:  
                         setattr(entry[1],'viewClassification','area')  
   
                 #entry[1].contentType == entry[1].content_type  
   
                 if entry[1].meta_type in ['ECHO_collection','ECHO_group']:  
                     entry[1].patchViewClassification(entry[1])      
   
                   
         return "changed all contenttypes in: "+self.title  
   
     def deleteCache(self,obj=None,RESPONSE=None):  
         """setze alle collections auf cache = CacheManager"""  
         if not obj:  
             obj = self  
         entries=obj.ZopeFind(obj,search_sub=1)  
         for entry in entries:  
                 if hasattr(entry[1],'_v_hash'):  
                         entry[1]._v_hash=None  
           
         return "changed all CM in: "+self.title  
   
       
     security.declarePublic('ECHO_newViewerLink')  
     def ECHO_newViewerLink(self,obj=None):  
         """change links (:86 faellt weg)"""  
   
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])  
   
         for entry in entries:  
                   
                 if entry[1].meta_type == 'ECHO_resource':  
                       
                     entry[1].link=re.sub('\:86','',entry[1].link)  
   
                 else:  
                       
                     entry[1].ECHO_newViewerLink(entry[1])  
                   
         return "Rerenderd all links to resources in: "+self.title  
   
     def __init__(self,id,title):  
         """init"""  
         self.id = id  
         self.title=title  
   
     def deleteSpace(self,str):  
         """delete space at the end of a line"""  
         if str[len(str)-1]==" ":  
             return str[0:len(str)-1]  
         else:  
             return str  
           
       
   
     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt  
   
     def formatAscii(self,str,url=None):  
         """ersetze ascii umbrueche durch <br>"""  
   
     if not str:   
             return ""  
   
         if url:  
               
             retStr=""  
             words=str.split("\n")  
               
             for word in words:  
                 strUrl=url%word  
   
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)  
             str=retStr  
         if str:  
             str = re.sub(r"[\n]","<br/>",str)  
             return unicodify(str)  
         else:  
             return u""  
           
     link2html=vlp_xmlhelpers.link2html  
     related2html=vlp_xmlhelpers.related2html  
   
     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):  
         """Quote string"""  
   
         return libpq.PgQuoteString(string)  
   
     security.declareProtected('View','getPartners')  
     def getPartners(self):  
         """Get list of Partners. Presently only from a subfolder partners"""  
         if hasattr(self,'partners'):              
                 ret = [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]  
                 def sort_title(one, another) : return cmp(one.title, another.title)  
                 ret.sort(sort_title)  
                 return ret  
         else:  
                 return []  
     
     def getInstitutions(self):  
         """Get list of Partners. Presently only from a subfolder partners"""  
                       
         return [ item[1] for item in self.institutions.ZopeFind(self.institutions,obj_metatypes=['ECHO_institution'])]  
   
      
     def getPartnersXML(self):  
         """partner liste als xml"""   
         partners=self.getPartners()  
         ret="""<?xml version="1.0" encoding="utf-8" ?>  
         <partners>"""  
           
         for partner in partners:  
             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)  
   
         return ret+"\n</partners>"  
       
     def getCollectionTree(self):  
         """get the collection tree (list of triples (parent,child, depth)"""  
   
         def getCollection(object,depth=0):  
             depth+=1  
             collections=[]  
             for entry in object.__dict__.keys():  
                 element=getattr(object,entry)  
                 try:  
                     if element.meta_type=="ECHO_collection":  
                         collections.append((object,element,depth))  
                         collections+=getCollection(element,depth)  
                 except:  
                     """nothing"""  
             return collections  
           
   
         return getCollection(self)  
       
     def getCollectionTreeIds(self):  
         """Show the IDs of the Tree"""  
         ret=[]  
         for collection in self.getCollectionTree():  
             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))  
         return ret  
   
     def getResourcesHTML(self,viewerType=None,filter=None):  
             """gebe all ressourcen aus"""  
   
             def sortHTML(x,y):  
                     return cmp(x[1].title,y[1].title)  
               
             ret="""<html><body><h2>Resources in ECHO</h3>"""  
               
             resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource','VLP_resource'],search_sub=1)  
             ret+="""<h3>Found %i resources</h3>"""%len(resources)  
             resources.sort(sortHTML)  
             for resource in resources:  
                     echo_url=resource[1].absolute_url()  
                       
                     if hasattr(resource[1],'title'):  
                             title=resource[1].title  
                     else:  
                             title="None"  
                     if filter:  
                             if re.search(filter,title):  
                                     ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)  
                     else:  
                             ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)  
   
             ret +="""\n</body></html>"""  
               
             #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")  
             #self.REQUEST.RESPONSE.write(ret)  
             return ret  
       
     def getResourcesXML(self,viewerType=None,filter=None):  
             """gebe all ressourcen aus"""  
             ret="""<?xml version="1.0" ?>  
                      <index>"""  
             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource','VLP_resource'],search_sub=1):  
   
                     echo_url=resource[1].absolute_url()  
                     if hasattr(resource[1],'link'):  
                             viewer_url=resource[1].link  
                     else:  
                             viewer_url="NO URL"  
                     if filter:  
                             if re.search(filter,viewer_url):  
                                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
                     else:  
                             ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
             ret +="""\n</index>"""  
               
             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
             self.REQUEST.RESPONSE.write(ret)  
   
     def getCollectionsXML(self,viewerType=None,filter=None):  
             """gebe collections aus"""  
             ret="""<?xml version="1.0" ?>  
                      <index>"""  
             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_collection','ECHO_group'],search_sub=1):  
   
                     echo_url=resource[1].absolute_url()  
                    
                     ret+="""\n<collection echoLink="%s"/>"""%urllib.quote(echo_url,safe='/:?')  
             ret +="""\n</index>"""  
               
             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
             self.REQUEST.RESPONSE.write(ret)  
   
     def getFullTextsXML(self,viewerType=None,filter=None):  
             """gebe all ressourcen aus"""  
             ret="""<?xml version="1.0" ?>  
                      <index>"""  
             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
   
                     echo_url=resource[1].absolute_url()  
                     if resource[1].getFullTextXML(noredirect="yes"):  
                             if hasattr(resource[1],'link'):  
                                     viewer_url=echo_url+"/getFullTextXML"  
                             else:  
                                     viewer_url="NO URL"  
                             if filter:  
                                     if re.search(filter,viewer_url):  
                                             ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
                             else:  
                                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
             ret +="""\n</index>"""  
               
               
             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
             self.REQUEST.RESPONSE.write(ret)  
   
   
     def getMetaDatasXML(self,viewerType=None,filter=None):  
             """gebe all ressourcen aus"""  
             # check if the request's host part was OK  
             http_host = self.REQUEST['HTTP_HOST']  
             host_port = self.REQUEST['SERVER_PORT']  
             fix_host = None  
             if http_host and http_host.rfind(host_port) == -1:  
                     print "HTTP_HOST needs fixing!"  
                     fix_host = http_host + ":" + host_port  
   
             ret="""<?xml version="1.0" ?>  
                      <index>"""  
             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
   
                     echo_url=resource[1].absolute_url()  
                     if fix_host:  
                             #print "replacing ", http_host, " by ", fix_host  
                             echo_url = string.replace(echo_url, http_host, fix_host, 1)  
                       
                     if hasattr(resource[1],'link'):  
                             meta_url=echo_url+"/getMetaDataXML"  
                     else:  
                             meta_url="NO_URL"  
                               
                     if filter and not re.search(filter,viewer_url):  
                             continue  
   
                     #modificationDate=time.strptime(str(resource[1].bobobase_modification_time()),"%Y/%m/%d %H:%M:%S %Z")  
                       
                     modificationDate=resource[1].bobobase_modification_time().strftime("%Y/%m/%d %H:%M:%S")  
   
                     ret+="""\n<resource resourceLink="%s" metaLink="%s" modificationDate="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'),modificationDate)  
                       
                               
             ret +="""\n</index>"""  
   
             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
             self.REQUEST.RESPONSE.write(ret)  
   
               
     def findPartners(self):       
         """find all partners in partners"""  
         par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')  
         return par  
           
     def getPartnerFromID(self):  
         """find partner form ID return object"""  
         pa=self.REQUEST['partner']  
         par=self.ZopeFind(self.partners, obj_ids=[pa])  
         return par  
           
     def getPartnerFromIDParameter(self, id):  
         """ find partners from ID"""  
         par=self.ZopeFind(self.partners, obj_ids=[id])  
         return par  
           
     def getInstitutionFromID(self,id):  
         """ find institution from id """  
         inst=self.ZopeFind(self.institutions, obj_ids=[id])  
         return inst  
   
     def 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):  
     """Add an ECHO_root"""  
     self._setObject(id,ECHO_root(id,title))  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
 def manage_addECHO_rootForm(self):  
         """Nothing yet"""  
         pt=zptFile(self, 'zpt/AddECHO_root.zpt')  
         return pt()  
   
 class ECHO_copyrightType(Folder,ECHO_basis):  class ECHO_copyrightType(Folder,ECHO_basis):
         """copyright typ"""          """copyright typ"""
Line 3173  def repairCoords(self): Line 2346  def repairCoords(self):
         msg += "\nDone!"          msg += "\nDone!"
         return msg          return msg
   
 from ECHO_Nav import ECHO_navigation  from ECHO_root import ECHO_main
   
 class ECHO_main(ECHO_root,ECHO_navigation):  
     """echo main object combines ECHO_root and ECHO_navigation"""  
       
     meta_type="ECHO_main"  
           
     def __init__(self,id,title):  #class ECHO_main(ECHO_root,ECHO_navigation):
         """init"""  #    """echo main object combines ECHO_root and ECHO_navigation"""
         self.id=id  #    
         self.title=title  #    meta_type="ECHO_main"
         self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.  #    
         self.displayedMetaTypes=displayTypes  #    def __init__(self,id,title):
           #        """init"""
           #        self.id=id
     manage_options = Folder.manage_options+(  #        self.title=title
         {'label':'Main Config','action':'ECHO_navigationConfigForm'},  #        self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.
         {'label':'Cache','action':'ECHO_cacheManageForm'},  #        self.displayedMetaTypes=displayTypes
         {'label':'Main Config','action':'ECHO_copyright_configForm'},  #        
         {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},  #        
         {'label':'Change Weights','action':'changeWeights'},  #    manage_options = Folder.manage_options+(
         {'label':'Generate from RDF','action':'generateFromRDFForm'},  #        {'label':'Main Config','action':'ECHO_navigationConfigForm'},
         {'label':'update Resource Catalog','action':'updateResourceCatalog'},  #        {'label':'Cache','action':'ECHO_cacheManageForm'},
         {'label':'Copy MD for indexing and search','action':'copySearchFields'},  #        {'label':'Main Config','action':'ECHO_copyright_configForm'},
         )  #        {'label':'Change Weights','action':'changeWeights'},
   #        {'label':'Generate from RDF','action':'generateFromRDFForm'},
       #        {'label':'update Resource Catalog','action':'updateResourceCatalog'},
 def manage_addECHO_mainForm(self):  #        {'label':'Copy MD for indexing and search','action':'copySearchFields'},
     """Form for adding"""  #        )
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)  #
     return pt()  #    
   #def manage_addECHO_mainForm(self):
 def manage_addECHO_main(self,id,title,RESPONSE=None):  #    """Form for adding"""
     """Add an ECHO_main"""  #    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)
     self._setObject(id,ECHO_main(id,title))  #    return pt()
       #
     obj=self._getOb(id)  #def manage_addECHO_main(self,id,title,RESPONSE=None):
     text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()  #    """Add an ECHO_main"""
       #    self._setObject(id,ECHO_main(id,title))
     manage_addPageTemplate(obj,'main_template',text=text)                 #    
       #    obj=self._getOb(id)
     #    text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()
     if RESPONSE is not None:  #    
         RESPONSE.redirect('manage_main')  #    manage_addPageTemplate(obj,'main_template',text=text)               
   #    
   #  
   #    if RESPONSE is not None:
   #        RESPONSE.redirect('manage_main')
Removed from v.1.300  
changed lines
  Added in v.1.310.2.11

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