[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.310 and 1.310.2.12

version 1.310, 2010/10/13 13:10:19 version 1.310.2.12, 2013/08/05 08:20:10
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:  try:
     from Products.MetaDataProvider.MetaDataClient import MetaDataClient      from Products.MetaDataProvider.MetaDataClient import MetaDataClient
 except:  except:
Line 49  import urllib2 Line 47  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
Line 83  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 544  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 697  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
   
Line 709  class ECHO_collection(CatalogAware, Fold Line 715  class ECHO_collection(CatalogAware, Fold
             return crumbs[0][2].getId()              return crumbs[0][2].getId()
           
         p = self          p = self
         
         sec = None          sec = None
         # descend parents to the root (and remember the last id)          # descend parents to the root (and remember the last id)
         while p is not None and p.meta_type != 'ECHO_root' and p.meta_type!='ECHO_main' and p.meta_type!='ECHO_nav':          while p is not None and p.meta_type not in self.rootMetaTypes:
             sec = p.getId()              sec = p.getId()
             p = p.aq_parent              p = aq_parent(p.context)
             
         return sec          return sec
           
Line 728  class ECHO_collection(CatalogAware, Fold Line 733  class ECHO_collection(CatalogAware, Fold
         sec = None          sec = None
         subsec = None          subsec = None
         # descend parents to the root (and remember the last id)          # descend parents to the root (and remember the last id)
         while p is not None and p.meta_type != 'ECHO_root' and p.meta_type!='ECHO_main' and p.meta_type!='ECHO_nav':          while p is not None and p.meta_type not in self.rootMetaTypes:
             subsec = sec              subsec = sec
             sec = p.getId()              sec = p.getId()
             p = p.aq_parent              p = aq_parent(p.context)
                       
         return subsec          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"""
         pt=zptFile(self, 'zpt/exportImportObjects.zpt')          pt=zptFile(self, 'zpt/exportImportObjects.zpt')
Line 910  class ECHO_collection(CatalogAware, Fold Line 924  class ECHO_collection(CatalogAware, Fold
             return ret+"</rdf:Seq>"              return ret+"</rdf:Seq>"
                           
   
       def getExportCollectionsAsJSON(self,metatypes=['ECHO_resource'],REQUEST=None):
           import json
           ret = self.getExport(metatypes=metatypes)
           
           if REQUEST:
                   REQUEST.response.setHeader("Content-type", "text/json; charset=utf-8")
            
           return json.dumps(ret)
       
       def getExport(self,metatypes=['ECHO_resource'],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=metatypes)
   
               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
               
       
          
       def getDRI(self,type="escidoc"):
           """sofar cho collections don't have dris
           therefore return the path"""
           
           return self.absolute_url().replace(self.echo_pages.absolute_url(),'')
               
               
             
           
     def changeLabels(self):      def changeLabels(self):
                 """change form"""                  """change form"""
Line 1078  class ECHO_collection(CatalogAware, Fold Line 1132  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 1134  class ECHO_collection(CatalogAware, Fold Line 1167  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 1200  class ECHO_collection(CatalogAware, Fold Line 1202  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 1443  class ECHO_collection(CatalogAware, Fold Line 1435  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 1462  class ECHO_collection(CatalogAware, Fold Line 1451  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 1506  class ECHO_collection(CatalogAware, Fold Line 1495  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 1516  class ECHO_collection(CatalogAware, Fold Line 1512  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 1561  class ECHO_collection(CatalogAware, Fold Line 1569  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 1618  class ECHO_collection(CatalogAware, Fold Line 1626  class ECHO_collection(CatalogAware, Fold
         return [x.absolute_url() for x in self.getSubCols(searchSimple=searchSimple)]          return [x.absolute_url() for x in self.getSubCols(searchSimple=searchSimple)]
           
           
       def exportPageTemplateContents(self,REQUEST=None):
           """hole nur den inhalt aus page templates"""
           
           import json
           import base64
           from BeautifulSoup import BeautifulSoup
           
           
           ret={}
           #contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])
           contents=self.ZopeFind(self,obj_metatypes=['Page Template'],search_sub=1)
           #contents=self.ZopeFind(self)
           
           
           for content in contents:
               colId = content[1].absolute_url().replace(self.absolute_url(),'')
            
               html=content[1].render()
               parsed = BeautifulSoup(html)
                   
                   
               cnt = parsed.findAll(attrs={'class':'stage'})
               if len(cnt) > 0: #sollte nur einen gebenbt:
                   ret[colId]=base64.b64encode(cnt[0].prettify())
                   
           if REQUEST:
                   REQUEST.response.setHeader("Content-type", "text/json; charset=utf-8")
          
            
           return json.dumps(ret)
         
 Globals.InitializeClass(ECHO_collection)  Globals.InitializeClass(ECHO_collection)
           
 def manage_addECHO_collectionForm(self):  def manage_addECHO_collectionForm(self):
Line 1910  def createNode(self,descrs,node): Line 1949  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('ascii','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 3233  def repairCoords(self): Line 2383  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.310  
changed lines
  Added in v.1.310.2.12

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