[BACK]Return to ECHO_Nav.py CVS log [TXT] [DIR] Up to [Repository] / ECHO_content

Diff for /ECHO_content/ECHO_Nav.py between versions 1.2 and 1.61

version 1.2, 2004/02/03 15:39:12 version 1.61, 2005/10/26 16:14:29
Line 1 Line 1
 # Objekte zur Erzeugung von Navigationselementen  # Objekte zur Erzeugung von Navigationselement
   from AccessControl import ClassSecurityInfo
   from Globals import DTMLFile
   from OFS.Image import Image,cookId
   from OFS.Folder import Folder
   from OFS.SimpleItem import SimpleItem
   from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   from Products.PageTemplates.PageTemplate import PageTemplate
   import re
   import string
   from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   import os.path
   from Globals import package_home
   import urllib
   from ECHO_helpers import *
   from ECHO_collection import content_html 
   from types import *
   
   
   from Globals import DTMLFile
   from OFS.Image import Image,cookId
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
Line 9  import re Line 27  import re
 import string  import string
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 import os.path  import os.path
 from Globals import package_home  
 import urllib  import urllib
   from ECHO_helpers import displayTypes,checkOnlyOneInGroup
   from ECHO_collection import content_html
   import zLOG
   
   try:    
       from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
   except:
       zLOG.LOG('ECHO_Nav',zLOG.INFO,'ZSQLSimpleSearch not supported')
   
   
   
   class ECHO_ZCatalogElement(SimpleItem):
       """Erzeuge navigation aus ZCatalog-abfrage"""
       meta_type="ECHO_ZCatalogElement"
       baseUrl=""
   
       def __init__(self,id,title,field,catalogId,baseUrl,weight,contentType):
           """init"""
           self.id=id
           self.title=title
           self.catalogId=catalogId
           self.field=field
   
           self.baseUrl=baseUrl
           self.weight=weight
           self.content=contentType
   
           
       manage_options= SimpleItem.manage_options+(
           {'label':'Main Config','action':'changeECHO_ZCatalogElementForm'},
           )
   
           
       def getWeight(self):
           """get weight"""
           if hasattr(self,'weight'):
               return self.weight
           else:
               return 0
           
       def getcontentType(self):
           """get weight"""
           
           if hasattr(self,'contentType'):
               return self.contentType
           else:
               return 0
           
   
       def changeECHO_ZCatalogElementForm(self):
           """change"""
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHO_ZCatalogElement.zpt')).__of__(self)
           return pt()
   
       def changeECHO_ZCatalogElement(self,title,field,catalogId,baseUrl,weight,contentType,RESPONSE=None):
           """change"""
           self.title=title
           self.catalogId=catalogId
           self.field=field
           self.baseUrl=baseUrl
           self.weight=weight
           self.contentType=contentType
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
       def getKeywordList(self):
           return getattr(self,self.catalogId).uniqueValuesFor(self.field)
       
       def getNavList(self):
           """ausgabe der treffer list für navigation"""
           
           records=self.getKeywordList()
           
           
           if not records:
               return []
           else:
               ret=[]
               for record in records:
                   #print "RC",record
                   #if record:
                   #    ret.append((record,self.baseUrl+urllib.quote(record)))
                   try:
                       ret.append((record,self.baseUrl+urllib.quote(record)))
                   except:
                       """nothing"""
                       
               return ret
       
   
   def manage_addECHO_ZCatalogElementForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_ZCatalogElement.zpt')).__of__(self)
       return pt()
   
   def manage_addECHO_ZCatalogElement(self,id,title,field,baseUrl,weight,contentType,RESPONSE=None):
       """Add an ECHO_ZCatalogelement"""
       self._setObject(id,ECHO_ZCatalogElement(id,title,field,baseUrl,weight,contentType))
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   
   
   class ECHO_contentType(Image):
       """ContentType Object"""
   
       meta_type="ECHO_contentType"
   
       
       manage_options=Image.manage_options+(
           {'label':'Change Description','action':'changeECHO_contentTypeForm'},
          )
   
       def changeECHO_contentTypeForm(self):
           """Change the description text"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHO_contentType.zpt')).__of__(self)
           return pt()
    
       def changeECHO_contentType(self,description,RESPONSE=None):
           """Change the Content"""
           self.description=description
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   manage_addECHO_contentTypeForm=DTMLFile('dtml/ECHO_contentTypeAdd',globals(),
                                Kind='ECHO_contentType',kind='ECHO_contentType')
   
   def manage_addECHO_contentType(self, id, file=None, title='', precondition='', content_type='', description='',
                       REQUEST=None):
       """
       Add a new Image object.
   
       Creates a new Image object 'id' with the contents of 'file'.
       """
   
       id=str(id)
       title=str(title)
       content_type=str(content_type)
       precondition=str(precondition)
   
       id, title = cookId(id, title, file)
   
       self=self.this()
   
       # First, we create the image without data:
       self._setObject(id, ECHO_contentType(id,title,'',content_type, precondition))
   
       self._getOb(id).description=description
           
       # Now we "upload" the data.  By doing this in two steps, we
       # can use a database trick to make the upload more efficient.
       if file:
           self._getOb(id).manage_upload(file)
       if content_type:
           self._getOb(id).content_type=content_type
   
       if REQUEST is not None:
           try:    url=self.DestinationURL()
           except: url=REQUEST['URL1']
           REQUEST.RESPONSE.redirect('%s/manage_main' % url)
       return id
   
   
 class ECHO_sqlElement(SimpleItem):  class ECHO_sqlElement(SimpleItem):
     """Erzeuge navigation aus sql-abfrage"""      """Erzeuge navigation aus sql-abfrage"""
     meta_type="ECHO_sqlElement"      meta_type="ECHO_sqlElement"
     baseUrl=""      baseUrl=""
           
     def __init__(self,id,title,query,field,baseUrl):  
       
       def __init__(self,id,title,query,field,searchField,baseUrl,weight,contentType):
         """init"""          """init"""
         self.id=id          self.id=id
         self.title=title          self.title=title
         self.query=query          self.query=query
         self.field=field          self.field=field
           if searchField=="":
               self.searchField=field
           else:
               self.searchField=searchField
         self.baseUrl=baseUrl          self.baseUrl=baseUrl
   
           self.content=contentType
   
     manage_options= SimpleItem.manage_options+(      manage_options= SimpleItem.manage_options+(
         {'label':'Main Config','action':'changeECHO_sqlElementForm'},          {'label':'Main Config','action':'changeECHO_sqlElementForm'},
         )          )
   
       def getSearchField(self):
           try:
               return self.searchField
           except:
               return self.field
           
       def getWeight(self):
           """get weight"""
           if hasattr(self,'weight'):
               return self.weight
           else:
               return 0
           
       def getcontentType(self):
           """get weight"""
           
           if hasattr(self,'contentType'):
               return self.contentType
           else:
               return 0
           
   
     def changeECHO_sqlElementForm(self):      def changeECHO_sqlElementForm(self):
         """change"""          """change"""
         pt=PageTemplateFile('Products/ECHO_content/ChangeECHO_sqlElement.zpt').__of__(self)          
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHO_sqlElement.zpt')).__of__(self)
         return pt()          return pt()
   
     def changeECHO_sqlElement(self,title,query,field,baseUrl,RESPONSE=None):      def changeECHO_sqlElement(self,title,query,field,searchField,baseUrl,weight,contentType,RESPONSE=None):
         """change"""          """change"""
         self.title=title          self.title=title
         self.query=query          self.query=query
         self.field=field          self.field=field
           self.searchField=searchField
         self.baseUrl=baseUrl          self.baseUrl=baseUrl
           self.weight=weight
           self.contentType=contentType
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def searchQuery(self):      try:    
         return self.search(var=self.query)          searchQuery=ZSQLExtendFolder.ZSQLSimpleSearch
       except:
           zLOG.LOG('ECHO_Nav',zLOG.INFO,'ZSQLSimpleSearch not supported')
           
     def getNavList(self):      def getNavList(self):
         """ausgabe der treffer list für navigation"""          """ausgabe der treffer list fuer navigation"""
         records=self.searchQuery()          
           #naechste schritte sind trial and error, warum geht mal das eine mal das andere 2.3 / 2.4 ??
           try:
               records=self.searchQuery(self.aq_parent,query=self.query) #python 2.4 version (??)
           except:
               records=self.searchQuery()#python 2.3 version(??)
         
           
         if not records:          if not records:
             return []              return []
         else:          else:
             ret=[]              ret=[]
             for record in records:              for record in records:
                 ret.append((getattr(record,self.field),self.baseUrl+str(getattr(record,self.field))))                  try:
                       ret.append((getattr(record,self.field),self.baseUrl+urllib.quote(str(getattr(record,self.getSearchField())))))
                   except:
                       """notrhing"""
                       
             return ret              return ret
           
   
 def manage_AddECHO_sqlElementForm(self):  def manage_addECHO_sqlElementForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/AddECHO_sqlElement.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_sqlElement.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_AddECHO_sqlElement(self,id,title,query,field,baseUrl,RESPONSE=None):  def manage_addECHO_sqlElement(self,id,title,query,field,searchField,baseUrl,weight,contentType,RESPONSE=None):
     """Add an ECHO_sqlelement"""      """Add an ECHO_sqlelement"""
     self._setObject(id,ECHO_sqlElement(id,title,query,field,baseUrl))      self._setObject(id,ECHO_sqlElement(id,title,query,field,searchField,baseUrl,weight,contentType))
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
   
   
 class ECHO_pageTemplate(ZopePageTemplate):  class ECHO_pageTemplate(ZopePageTemplate,ECHO_basis):
     """pageTemplate Objekt"""      """pageTemplate Objekt"""
     meta_type="ECHO_pageTemplate"      meta_type="ECHO_pageTemplate"
       security=ClassSecurityInfo()
       
   
     _default_content_fn = os.path.join(package_home(globals()),      _default_content_fn = os.path.join(package_home(globals()),
                                        'ECHO_pageTemplateDefault.html')                                         'html/ECHO_pageTemplateDefault.html')
   
       manage_options=ZopePageTemplate.manage_options+ECHO_basis.manage_options+(
           {'label':'Main Config','action':'changeECHO_pageTemplateMainForm'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
           )
   
       security.declarePublic('content_html')
   
       def addChanges(self):
           """do nothing leere methode, notwendig, da bei veerbung 
           von dieser klasse nur ueberschrieben werden kann, 
           falls methode per url aufgerufen werden soll"""
   
           return True
       
       def content_html(self):
           """content_html"""
           return content_html(self,'pageTemplate')
   
       def changeECHO_pageTemplateMainForm(self):
           """change"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeECHO_pageTemplateMain.zpt')).__of__(self)
           return pt()
   
       def changeECHO_pageTemplateMain(self,weight,contentType,label,description,RESPONSE=None,isAlwaysClickable=None,suffix=None,prefix=None):
           """change"""
           self.weight=weight
           self.contentType=contentType
           self.label=label
           self.description=description
           self.isAlwaysClickable=isAlwaysClickable
           self.suffix=suffix
           self.prefix=prefix
           
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
        
       def getWeight(self):
           """get weight"""
           if hasattr(self,'weight'):
               return self.weight
           else:
               return 0
   
     ## def __init__(self, id, text=None, content_type=None):      def getcontentType(self):
           """get contentType"""
           if hasattr(self,'contentType'):
               return self.contentType
           else:
               return 0
   
   
   
   
       ## def __init__(self, id, text=None, contentType=None):
 ##         self.id = str(id)  ##         self.id = str(id)
 ##         self.ZBindings_edit(self._default_bindings)  ##         self.ZBindings_edit(self._default_bindings)
 ##         if text is None:  ##         if text is None:
 ##             text = open(self._default_cont).read()  ##             text = open(self._default_cont).read()
 ##         self.pt_edit(text, content_type)  ##         self.pt_edit(text, contentType)
   
 def manage_AddECHO_pageTemplateForm(self):  def manage_addECHO_pageTemplateForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/AddECHO_pageTemplate.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_pageTemplate.zpt')).__of__(self)
     return pt()      return pt()
   
 from urllib import quote  from urllib import quote
   
   
 def manage_AddECHO_pageTemplate(self, id, title=None, text=None,  def manage_addECHO_pageTemplate(self, id, label, weight= 0,contentType=0,title=None, text=None,
                            REQUEST=None, submit=None):                             REQUEST=None, submit=None):
     "Add a Page Template with optional file content."      "Add a Page Template with optional file content."
   
Line 104  def manage_AddECHO_pageTemplate(self, id Line 387  def manage_AddECHO_pageTemplate(self, id
     if REQUEST is None:      if REQUEST is None:
         self._setObject(id, ECHO_pageTemplate(id, text))          self._setObject(id, ECHO_pageTemplate(id, text))
         ob = getattr(self, id)          ob = getattr(self, id)
           setattr(ob,'weight',weight)
           setattr(ob,'label',label)
           setattr(ob,'contentType',contentType)
         if title:          if title:
             ob.pt_setTitle(title)              ob.pt_setTitle(title)
         return ob          return ob
Line 113  def manage_AddECHO_pageTemplate(self, id Line 399  def manage_AddECHO_pageTemplate(self, id
         if headers is None or not file.filename:          if headers is None or not file.filename:
             zpt = ECHO_pageTemplate(id)              zpt = ECHO_pageTemplate(id)
         else:          else:
             zpt = ECHO_pageTemplate(id, file, headers.get('content_type'))              zpt = ECHO_pageTemplate(id, file, headers.get('contentType'))
   
         self._setObject(id, zpt)          self._setObject(id, zpt)
           ob = getattr(self, id)
           setattr(ob,'weight',weight)
           setattr(ob,'label',label)
           if title:
               ob.pt_setTitle(title)
   
         try:          try:
             u = self.DestinationURL()              u = self.DestinationURL()
Line 132  class ECHO_navigation(Folder): Line 423  class ECHO_navigation(Folder):
     """Navigations Element"""      """Navigations Element"""
     meta_type="ECHO_Navigation"      meta_type="ECHO_Navigation"
   
     displayedMetaTypes=['ECHO_collection','ECHO_pageTemplate','ZSQLExtendFolder','ECHO_sqlElement']      def getNavInfo(self):
           """root informationen"""
           if hasattr(self,'logo_image'):
               if hasattr(self.logo_image,'tag'):
                   imageTag=self.logo_image.tag()
           else:
               imageTag=''
           return (self.title,imageTag)
   
       def linkBar(self,parent):
           """linkbarer balken"""
           str=""
   
           
           while not(parent.meta_type == "ECHO_root"):
               fragment="""<a href="%s">%s</a>"""%(parent.absolute_url(),parent.label)
               str=fragment+"/"+str
               parent=parent.aq_parent
   
           return str
       
       def decode(self,str):
           """decoder"""
           if not str:
               return ""
           if type(str)==StringType:
               
               return str
           else:
               try:
                   return str.encode('utf-8')
               except:
                   return str.encode('latin-1')
       def ECHOFormatListStr(self,list,search="\n",replace="<br>"):
           """formatiert liste im str"""
           if list:
                   return re.sub(search,replace,list)
           else:
                   return 
   
       def ECHO_cacheManageForm(self):
               """change form"""
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_cacheManageForm')).__of__(self)
               pt.content_type="text/html"
               return pt()
   
       def ECHO_cacheManage(self,cacheManagerName=None,deleteCache=None, activateCache=None,RESPONSE=None):
               """cachemanager"""
               if cacheManagerName=="": chacheManagerName=None
               
               self.cacheManagerName=cacheManagerName
               self.setCache(managerName=cacheManagerName)
               
               if deleteCache:
                   try:
                       self.deleteCache()
                   except:
                       for roots in self.ZopeFind(self,obj_metatypes=['ECHO_root'],search_sub=1):
                           roots[1].deleteCache()
                       
   
               self.activateCache=activateCache
   
               if RESPONSE is not None:
                       RESPONSE.redirect('manage_main')
           
       def setCache(self,obj=None,RESPONSE=None,managerName='CacheManager'):
           """setze alle collections auf cache = CacheManager"""
   
   
           if not obj:
               obj = self
               
           entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_collection','VLP_resource'],search_sub=1)
   
           for entry in entries:
               entry[1].ZCacheable_setManagerId(managerName)
   
           
           return "changed all CM in: "+self.title
   
       
   
       displayableMetaTypes=displayTypes
       
       def getImageViewers(self):
           """images"""
           viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])
           return viewers
       
       def getR(self):
           """re"""
           return self.REQUEST
           
     def __init__(self,id,title,pathToHierarchy):      def __init__(self,id,title,pathToHierarchy):
         """init"""          """init"""
         self.id=id          self.id=id
         self.title=title          self.title=title
         self.pathToHierarchy=pathToHierarchy          self.pathToHierarchy=pathToHierarchy
           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'},
   
         )          )
       displayedMetaTypes=displayTypes
   
     def ECHO_navigationConfigForm(self):      def ECHO_navigationConfigForm(self):
         """configForm"""          """configForm"""
         pt=PageTemplateFile('Products/ECHO_content/ChangeECHO_navigation.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeECHO_navigation.zpt')).__of__(self)
         return pt()          return pt()
           
     def ECHO_navigationConfig(self,title,pathToHierarchy,RESPONSE=None):      def ECHO_navigationConfig(self,title,pathToHierarchy,displayedMetaTypes=displayTypes,RESPONSE=None):
         """config"""          """config"""
         self.title=title          self.title=title
         self.pathToHierarchy=pathToHierarchy          self.pathToHierarchy=pathToHierarchy
           self.displayedMetaTypes=toList(displayedMetaTypes)[0:]
   
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def getColls(self,obj,depth):      def getColls(self,obj,depth,checkOnly="no"):
         nav={}          nav={}
         #print "HERE",obj.          #print "HERE",obj.
         for keys in obj.__dict__.keys():          for x_objs in obj.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes):
             x=getattr(obj,keys)              x=x_objs[1]
             if hasattr(x,"meta_type"):              if checkOnly=="yes":
                 if x.meta_type in self.displayedMetaTypes:                  x = checkOnlyOneInGroup(x)
                     if depth>1:                      if depth>1:
                         nav[x.getId()]=(self.getColls(x,depth-1),x)                          nav[x.getId()]=(self.getColls(x,depth-1),x)
                     else:                      else:
                         nav[x.getId()]=(None,x)                          nav[x.getId()]=(None,x)
         return nav          return nav
           
     def createNavHash(self,depth):      def createNavHash(self,depth,checkOnly="no"):
         """Auslesen des Hierarchiebuames"""          """Auslesen des Hierarchiebuames"""
         temp=self.pathToHierarchy[0:]          temp=self.pathToHierarchy[0:]
         temp=re.sub("/",".",temp)          temp=re.sub("/",".",temp)
         temp="self.aq_parent"+temp          temp="self.aq_parent"+temp
                   
           
         objtemp=eval(temp)          objtemp=eval(temp)
         nav={}          nav={}
         obj=objtemp  
                   
         #exec(obj)          #check if cash is enabled and if already exists and if not empty
           if getattr(self,'_v_hash',None) and getattr(self,'activateCache',None) and self._v_hash.get(str(depth),None):
              
              return self._v_hash[str(depth)]
   
           # if not generate new hash
           obj=objtemp      
   
         #objtemp = compile(temp,'<string>','single')          for keys in obj.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes):
         #obj=eval(objtemp)              x=keys[1]
         print obj   
           
         #print obj.__dict__.keys()  
           
         for keys in obj.__dict__.keys():  
             x=getattr(obj,keys)  
             if hasattr(x,"meta_type"):  
                 #print x.meta_type  
                 if x.meta_type in self.displayedMetaTypes:  
                     if depth>1:                      if depth>1:
                         nav[x.getId()]=(self.getColls(x,int(depth)-1),x)                  nav[x.getId()]=(self.getColls(x,int(depth)-1,checkOnly),x)
                     else:                      else:
                         nav[x.getId()]=(None,x)                          nav[x.getId()]=(None,x)
                                           
           #store in cache if activated
           if getattr(self,'activateCache',None):
               
               try:
                   self._v_hash[str(depth)]={}
               except:
                   self._v_hash={}
                   self._v_hash[str(depth)]={}
   
               for x in nav.keys():
                   self._v_hash[str(depth)][x]=nav[x]
   
         #print nav  
         return nav          return nav
   
     def barFromHash(self,hash,start=None):      def barFromHash(self,hash,start=None,sortField=None,location=None):
         """Erzeuge Navigations Element"""          """Erzeuge Navigations Element"""
         #print "hash",hash          #print "hash",hash
         listNav=[]          listNav=[]
         if not start:          if not start:
             temp=hash              temp=hash
         else: # list mit pfad zum hash              sortField="weight"
           else: # liste mit pfad zum hash
             temp=hash              temp=hash
               #print "HI",sortField
               if not sortField:
                   tempObj=self.pathToHierarchy[0:]
                   tempObj=re.sub("/",".",tempObj)
                   tempObj="self.aq_parent"+tempObj
                   #print tempObj
                   objtemp=eval(tempObj)
   
                   obj=objtemp
   
             for x in start:              for x in start:
                       #print "OBJ",start,obj,obj.getId(),x
   
                       obj=getattr(obj,x)
   
                   if hasattr(obj,'sortfield'):
                       sortField=obj.sortfield
                   else:
                       sortField='weight'
               #print "START",start
               for x in start:
                   #print "N2",x,temp[x]
                   try:
                 temp=temp[x][0]                  temp=temp[x][0]
                   except:
                       """nothing"""
                       return []
               #print "TEMP",temp,self.tempSorted(temp, field=sortField)
   
           for x in self.tempSorted(temp, field=sortField):
               
               if not temp[x][1].title == "":
                   
                   if (temp[x][1].meta_type=="ECHO_sqlElement") or (temp[x][1].meta_type=="ECHO_ZCatalogElement"):
   
         for x in temp.keys():  
             if temp[x][1].meta_type=="ECHO_sqlElement":  
                 for z in temp[x][1].getNavList():                  for z in temp[x][1].getNavList():
                     listNav.append((z[0],z[1]))                          listNav.append((z[0],z[1],None,'',''))
               
             else:              else:
                 listNav.append((temp[x][1].title,self.absolute_url()+createPath(temp[x][1].absolute_url())))                      # add label falls existiert und nicht leer
                       if hasattr(temp[x][1],'label'):
   
         #print listNav                          if not temp[x][1].label=='':
                               try:
                                   label=temp[x][1].getLabel()
                               except:
                                   label=temp[x][1].label
                           else:
                               label=temp[x][1].title.encode('utf-8')
                       else:
                           label=temp[x][1].title.encode('utf-8')                            
   
         #html=""                      if location:
         #for k in listNav:  
         #    print k                          loc=getattr(temp[x][1],'location','top')
         #    html=html+"<a href='%s'>%s</a>   "% (self.absolute_url()+createPath(k[1][1].absolute_url()),k[0])                          if (loc==location):
                               listNav.append((label,createPath(self.absolute_url(),temp[x][1].absolute_url())+getattr(temp[x][1],'queryString',''),temp[x][1],getattr(temp[x][1],'prefix',''),getattr(temp[x][1],'suffix','')))
                       else:
                           listNav.append((label,createPath(self.absolute_url(),temp[x][1].absolute_url())+getattr(temp[x][1],'queryString',''),temp[x][1],getattr(temp[x][1],'prefix',''),getattr(temp[x][1],'suffix','')))
   
         return listNav          return listNav
   
       def tempSorted(self,hash,field="weight"):
           ls=[]
   
           for x in hash.keys():
               #print hash[x][1]
               if hasattr(hash[x][1],field):
                   try:
                       weight=int(getattr(hash[x][1],field))
                   except:
                       weight=getattr(hash[x][1],field)
                   #print weight
               else:
                   weight=0
   
               ls.append((x,weight))
   
           ls.sort(sortWeight)
           
           return [x[0] for x in ls]
   
       
           
               
     def isSelectedPath(self,item):      def isSelectedPath(self,item):
         """test is path is already selected"""          """test is path is already selected"""
   
           testStr=re.sub("/index_html",'',self.REQUEST.get('URL',''))
   
           #falls exakte Übereinstimmung dann immer 1
           if (testStr==item[1]) and (self.REQUEST.get('QUERY_STRING','')==''):
               
               return 1
              
         found=re.search("\?(.*)",item[1])          found=re.search("\?(.*)",item[1])
           
         if found:          if found:
             temp=re.sub(" ","%20",found.group(0))              temp=re.sub(" ","%20",found.group(0))
             
             #print temp+"::"+self.REQUEST['QUERY_STRING']              #print temp+"::"+self.REQUEST['QUERY_STRING']
             if ("?"+self.REQUEST['QUERY_STRING'])==temp:              if ("?"+self.REQUEST['QUERY_STRING'])==temp:
                   if getattr(item[2],'isAlwaysClickable',None): #immer auswaehlbar?
                   
                       return 2
                   else:
                       return 1
   
           if (getattr(item[2],'meta_type','')=="ECHO_pageTemplate") and (re.search(item[1],self.REQUEST['URL'])):
               if getattr(item[2],'isAlwaysClickable',None): #immer auswaehlbar?
                   
                   return 2
               else:
                 return 1                  return 1
   
         if re.search(item[1],self.REQUEST['URL']):          if re.search(item[1]+"/",self.REQUEST['URL']):
               if getattr(item[2],'isAlwaysClickable',None): #immer auswaehlbar?
                   
                   return 2
               else:
             return 1              return 1
         else:          else:
             return 0              return 0
                   
           
       def getPathStyle(self, item, style=""):
           """returns a string with the given style + 'sel' if the path is already selected."""
   
           if self.isSelectedPath(item):
               return style + 'sel'
           else:
               return style
           
       
     def buttonsFromHash(self,hash,start=None,orientation="horizontal"):      def buttonsFromHash(self,hash,start=None,orientation="horizontal"):
                   
         """Generate Buttons"""          """Generate Buttons"""
Line 268  class ECHO_navigation(Folder): Line 765  class ECHO_navigation(Folder):
                 temp=temp[x][0]                  temp=temp[x][0]
                 #print temp                  #print temp
                   
         for key in temp.keys():          for key in self.tempSorted(temp):
                           
             description=temp[x][1].title              description=temp[x][1].title
                     
             url=self.absolute_url()+createPath(temp[key][1].absolute_url())              url=createPath(self.absolute_url(),temp[key][1].absolute_url())
   
             if (self.REQUEST['URL']==url) | (self.REQUEST['URL']==url+"/index_html"):              if (self.REQUEST['URL']==url) | (self.REQUEST['URL']==url+"/index_html"):
                 html=html+startTag+"[%s]" % description+endTag                  html=html+startTag+"[%s]" % description+endTag
Line 287  class ECHO_navigation(Folder): Line 784  class ECHO_navigation(Folder):
     def mainNavBar(self):      def mainNavBar(self):
         """print main navigation bar"""          """print main navigation bar"""
         keys=""          keys=""
   
         try:          try:
             keys=self.buttonsFromHash(self.createNavHash(0))              keys=self.buttonsFromHash(self.createNavHash(0))
         except:          except:
Line 294  class ECHO_navigation(Folder): Line 792  class ECHO_navigation(Folder):
                           
         return keys          return keys
   
     def mainNavElements(self):      def mainNavElements(self,location=None):
         """print main navigation bar"""          """print main navigation bar"""
         keys=""          keys=""
           #print "NAVELEMENT",self.getId()
           #try:
           
           keys=self.barFromHash(self.createNavHash(0),location=location)
           
           #except:
           #    keys=""
               
           return keys
   
       def numberOfMainNavElements(self):
           """number of main elements"""
   
           return len(self.barFromHash(self.createNavHash(0))) 
   
       def startOfHierarchy(self,list):
           splitted=self.pathToHierarchy.split("/")
           last=splitted[len(splitted)-1]
           #print last,list
         try:          try:
             keys=self.barFromHash(self.createNavHash(0))              nr=list.index(last)
         except:          except:
             keys=""              nr=0
           return nr+1
       
       def secondNavElements(self):
           """Zweite Ordnung Navigationselemente"""
           
           hash=self.createNavHash(2,checkOnly="no")
           actual_url=self.REQUEST['URL']
           
           ult_temp=re.sub(self.absolute_url(),"",actual_url)
           #print ult_temp
   
           splitted=ult_temp.split("/")
           
           #print "AU",self.absolute_url(),splitted
           #start=[splitted[2]] #orig
           startNr= self.startOfHierarchy(splitted)
           
           start=[splitted[startNr]]
           
           #print start
          
           keys=self.barFromHash(hash,start=start)
           
                           
         return keys          return keys
           
     def secondNavElements(self):      def navElements(self,order):
         """Zweite Ordnung"""          """n-te Ordnung"""
                   
         hash=self.createNavHash(2)          hash=self.createNavHash(order)
         actual_url=self.REQUEST['URL']          actual_url=self.REQUEST['URL']
                   
         ult_temp=re.sub(self.absolute_url(),"",actual_url)          ult_temp=re.sub(self.absolute_url(),"",actual_url)
Line 322  class ECHO_navigation(Folder): Line 861  class ECHO_navigation(Folder):
 ##         else:  ##         else:
 ##             start=[splitted[len(splitted)-1]]  ##             start=[splitted[len(splitted)-1]]
   
         start=[splitted[2]]          #start=splitted[2:order+1] #orig
           startNr= self.startOfHierarchy(splitted)
           #print startNr
           start=splitted[startNr:order+startNr-1] 
         #print start          #print start
                   
         keys=self.barFromHash(hash,start=start)          keys=self.barFromHash(hash,start=start)
Line 356  class ECHO_navigation(Folder): Line 898  class ECHO_navigation(Folder):
                   
         return keys          return keys
   
 def manage_AddECHO_navigationForm(self):  def manage_addECHO_navigationForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/AddECHO_navigation.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_navigation.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_AddECHO_navigation(self,id,title,pathToHierarchy,RESPONSE=None):  def manage_addECHO_navigation(self,id,title,pathToHierarchy,RESPONSE=None):
     """Add an ECHO_root"""      """Add an ECHO_root"""
     self._setObject(id,ECHO_navigation(id,title,pathToHierarchy))      self._setObject(id,ECHO_navigation(id,title,pathToHierarchy))
           
Line 371  def manage_AddECHO_navigation(self,id,ti Line 913  def manage_AddECHO_navigation(self,id,ti
   
 #helpers  #helpers
   
 def createPath(url):  
     temp=url.split("/")  
     del temp[0]  def createPath(url1,url2):
     del temp[1]      temp1=url1.split("/")
     return string.join(temp,"/")      temp2=url2.split("/")
       for test in temp1:
           if temp2[0]==test:
               del temp2[0]
   
       #print "CP:"+url1+"::"+url2+"::"+url1+"/"+string.join(temp2,"/")
       return url1+"/"+string.join(temp2,"/")
   
   def sortWeight(x,y):
       #print x[1],y[1]
       return cmp(x[1],y[1])
           
Removed from v.1.2  
changed lines
  Added in v.1.61

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