[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.2.12 and 1.311

version 1.310.2.12, 2013/08/05 08:20:10 version 1.311, 2011/11/03 11:05:25
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 36  from Globals import Persistent, package_ Line 40  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 47  import urllib2 Line 49  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 81  except: Line 83  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 701  class ECHO_collection(CatalogAware, Fold Line 697  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 715  class ECHO_collection(CatalogAware, Fold Line 709  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 not in self.rootMetaTypes:          while p is not None and p.meta_type != 'ECHO_root' and p.meta_type!='ECHO_main' and p.meta_type!='ECHO_nav':
             sec = p.getId()              sec = p.getId()
             p = aq_parent(p.context)              p = p.aq_parent
             
         return sec          return sec
           
Line 733  class ECHO_collection(CatalogAware, Fold Line 728  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 not in self.rootMetaTypes:          while p is not None and p.meta_type != 'ECHO_root' and p.meta_type!='ECHO_main' and p.meta_type!='ECHO_nav':
             subsec = sec              subsec = sec
             sec = p.getId()              sec = p.getId()
             p = aq_parent(p.context)              p = p.aq_parent
                       
         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 924  class ECHO_collection(CatalogAware, Fold Line 910  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 1132  class ECHO_collection(CatalogAware, Fold Line 1078  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/changeECHOViewer')              pt=zptFile(self, 'zpt/changeViewerTemplateSet')
             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 text tool field  der Collection not implemented yet!"""              """Lese viewerTemplateSet 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 1167  class ECHO_collection(CatalogAware, Fold Line 1134  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 1202  class ECHO_collection(CatalogAware, Fold Line 1200  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 1435  class ECHO_collection(CatalogAware, Fold Line 1443  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':'Change Image Viewer','action':'changeViewerForm'},          {'label':'Set Startpage','action':'setStartpageFolderForm'},
           {'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 1451  class ECHO_collection(CatalogAware, Fold Line 1462  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 1495  class ECHO_collection(CatalogAware, Fold Line 1506  class ECHO_collection(CatalogAware, Fold
           
     def showOverview(self):      def showOverview(self):
         """overview"""          """overview"""
         # use ECHO_overview.html template in this instance          # ECHO_overview.html template for this instance
         if 'ECHO_overview.html' in self:          if 'ECHO_overview.html' in self.__dict__.keys():
             return self['ECHO_overview.html']()              return getattr(self,'ECHO_overview.html')()
                   
         # use ECHO_overview_main template in path          # ECHO_overview_main template in path
         if hasattr(self, 'ECHO_overview_main'):          if hasattr(self, 'ECHO_overview_main'):
             return getattr(self, 'ECHO_overview_main')()              return getattr(self, 'ECHO_overview_main')()
                   
         # use template from Product          # template from product
         pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')          pt=zptFile(self, 'zpt/ECHO_content_overview.zpt')
         return pt()          return pt()
   
Line 1512  class ECHO_collection(CatalogAware, Fold Line 1523  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
                           
         # old Zope 2.9 method          if 'index.html' in self.__dict__.keys():
         #if 'index.html' in self.__dict__.keys():              ret=getattr(self,'index.html')()
         #    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:          elif 'overview' in self.__dict__.keys():
             # 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 1569  class ECHO_collection(CatalogAware, Fold Line 1568  class ECHO_collection(CatalogAware, Fold
   
     def area_img(self):      def area_img(self):
         """area image"""          """area image"""
         bt = browserType(self)          bt = BrowserCheck(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 1626  class ECHO_collection(CatalogAware, Fold Line 1625  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 1949  def createNode(self,descrs,node): Line 1917  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 2383  def repairCoords(self): Line 3240  def repairCoords(self):
         msg += "\nDone!"          msg += "\nDone!"
         return msg          return msg
   
 from ECHO_root import ECHO_main  from ECHO_Nav import ECHO_navigation
   
 #class ECHO_main(ECHO_root,ECHO_navigation):  class ECHO_main(ECHO_root,ECHO_navigation):
 #    """echo main object combines ECHO_root and ECHO_navigation"""      """echo main object combines ECHO_root and ECHO_navigation"""
 #          
 #    meta_type="ECHO_main"      meta_type="ECHO_main"
 #          
 #    def __init__(self,id,title):      def __init__(self,id,title):
 #        """init"""          """init"""
 #        self.id=id          self.id=id
 #        self.title=title          self.title=title
 #        self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.          self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.
 #        self.displayedMetaTypes=displayTypes          self.displayedMetaTypes=displayTypes
 #                  
 #                  
 #    manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
 #        {'label':'Main Config','action':'ECHO_navigationConfigForm'},          {'label':'Main Config','action':'ECHO_navigationConfigForm'},
 #        {'label':'Cache','action':'ECHO_cacheManageForm'},          {'label':'Cache','action':'ECHO_cacheManageForm'},
 #        {'label':'Main Config','action':'ECHO_copyright_configForm'},          {'label':'Main Config','action':'ECHO_copyright_configForm'},
 #        {'label':'Change Weights','action':'changeWeights'},          {'label':'Reload Metadata','action':'reloadMetaDataFromStorageWarning'},
 #        {'label':'Generate from RDF','action':'generateFromRDFForm'},          {'label':'Change Weights','action':'changeWeights'},
 #        {'label':'update Resource Catalog','action':'updateResourceCatalog'},          {'label':'Generate from RDF','action':'generateFromRDFForm'},
 #        {'label':'Copy MD for indexing and search','action':'copySearchFields'},          {'label':'update Resource Catalog','action':'updateResourceCatalog'},
 #        )          {'label':'Copy MD for indexing and search','action':'copySearchFields'},
 #          )
 #      
 #def manage_addECHO_mainForm(self):      
 #    """Form for adding"""  def manage_addECHO_mainForm(self):
 #    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)      """Form for adding"""
 #    return pt()      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)
 #      return pt()
 #def manage_addECHO_main(self,id,title,RESPONSE=None):  
 #    """Add an ECHO_main"""  def manage_addECHO_main(self,id,title,RESPONSE=None):
 #    self._setObject(id,ECHO_main(id,title))      """Add an ECHO_main"""
 #          self._setObject(id,ECHO_main(id,title))
 #    obj=self._getOb(id)      
 #    text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()      obj=self._getOb(id)
 #          text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()
 #    manage_addPageTemplate(obj,'main_template',text=text)                     
 #          manage_addPageTemplate(obj,'main_template',text=text)               
 #        
 #    if RESPONSE is not None:    
 #        RESPONSE.redirect('manage_main')      if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
Removed from v.1.310.2.12  
changed lines
  Added in v.1.311

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