[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.21 and 1.81

version 1.21, 2004/05/06 13:05:49 version 1.81, 2007/08/15 11:05:43
Line 1 Line 1
 # Objekte zur Erzeugung von Navigationselementen  # Objekte zur Erzeugung von Navigationselement
   from AccessControl import ClassSecurityInfo
 from Globals import DTMLFile  from Globals import DTMLFile
 from OFS.Image import Image,cookId  from OFS.Image import Image,cookId
 from OFS.Folder import Folder  from OFS.Folder import Folder
Line 12  from Products.PageTemplates.ZopePageTemp Line 12  from Products.PageTemplates.ZopePageTemp
 import os.path  import os.path
 from Globals import package_home  from Globals import package_home
 import urllib  import urllib
 from ECHO_helpers import displayTypes,checkOnlyOneInGroup  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.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
   
   import urllib
   from ECHO_helpers import displayTypes,checkOnlyOneInGroup,unicodify
   from ECHO_collection import content_html
   import logging
   
   #def ersetzt logging
   def logger(txt,method,txt2):
       """logging"""
       logging.info(txt+ txt2)
   
   
   try:    
       from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
   except:
       logger('ECHO_Nav',logging.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):
           try:
               return getattr(self,self.catalogId).uniqueValuesFor(self.field)
           except:
               #return getattr(self,self.catalogId).query(self.field)
   
               list= [x for x in getattr(getattr(self,self.catalogId),self.field).words()]
               list.sort()
               return list
       
       def getNavList(self):
           """ausgabe der treffer list fuer navigation"""
           
           records=self.getKeywordList()
           
           records=[x.encode('utf-8') for x in records]
           records.sort()
           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,catalogId,baseUrl,weight,contentType,RESPONSE=None):
       """Add an ECHO_ZCatalogelement"""
   
       self._setObject(id,ECHO_ZCatalogElement(id,title,field,catalogId,baseUrl,weight,contentType))
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   
   
 class ECHO_contentType(Image):  class ECHO_contentType(Image):
     """ContentType Object"""      """ContentType Object"""
Line 26  class ECHO_contentType(Image): Line 162  class ECHO_contentType(Image):
   
     def changeECHO_contentTypeForm(self):      def changeECHO_contentTypeForm(self):
         """Change the description text"""          """Change the description text"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/changeECHO_contentType.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHO_contentType.zpt')).__of__(self)
         return pt()          return pt()
   
     def changeECHO_contentType(self,description,RESPONSE=None):      def changeECHO_contentType(self,description,RESPONSE=None):
Line 79  class ECHO_sqlElement(SimpleItem): Line 215  class ECHO_sqlElement(SimpleItem):
     meta_type="ECHO_sqlElement"      meta_type="ECHO_sqlElement"
     baseUrl=""      baseUrl=""
           
   
       
     def __init__(self,id,title,query,field,searchField,baseUrl,weight,contentType):      def __init__(self,id,title,query,field,searchField,baseUrl,weight,contentType):
         """init"""          """init"""
         self.id=id          self.id=id
Line 90  class ECHO_sqlElement(SimpleItem): Line 228  class ECHO_sqlElement(SimpleItem):
         else:          else:
             self.searchField=searchField              self.searchField=searchField
         self.baseUrl=baseUrl          self.baseUrl=baseUrl
         self.weight=weight  
         self.content=contentType          self.content=contentType
   
     manage_options= SimpleItem.manage_options+(      manage_options= SimpleItem.manage_options+(
Line 122  class ECHO_sqlElement(SimpleItem): Line 260  class ECHO_sqlElement(SimpleItem):
     def changeECHO_sqlElementForm(self):      def changeECHO_sqlElementForm(self):
         """change"""          """change"""
                   
         pt=PageTemplateFile('Products/ECHO_content/zpt/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,searchField,baseUrl,weight,contentType,RESPONSE=None):      def changeECHO_sqlElement(self,title,query,field,searchField,baseUrl,weight,contentType,RESPONSE=None):
Line 138  class ECHO_sqlElement(SimpleItem): Line 276  class ECHO_sqlElement(SimpleItem):
         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:
           logger('ECHO_Nav',logging.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:
               try:
                   records=self.ZSQLSimpleSearch(query=self.query)
               except:
                   records=self.searchQuery(self.aq_parent,query=self.query) #python 2.4 version (??)
           except:
               records=self.searchQuery(query=self.query)#python 2.3 version(??)
         
    
         if not records:          if not records:
             return []              return []
         else:          else:
Line 152  class ECHO_sqlElement(SimpleItem): Line 303  class ECHO_sqlElement(SimpleItem):
                 try:                  try:
                     ret.append((getattr(record,self.field),self.baseUrl+urllib.quote(str(getattr(record,self.getSearchField())))))                      ret.append((getattr(record,self.field),self.baseUrl+urllib.quote(str(getattr(record,self.getSearchField())))))
                 except:                  except:
                       logger('ECHO_Nav',logging.INFO,"error, search")
                     """notrhing"""                      """notrhing"""
                                           
             return ret              return ret
Line 159  class ECHO_sqlElement(SimpleItem): Line 311  class ECHO_sqlElement(SimpleItem):
   
 def manage_addECHO_sqlElementForm(self):  def manage_addECHO_sqlElementForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/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,searchField,baseUrl,weight,contentType,RESPONSE=None):  def manage_addECHO_sqlElement(self,id,title,query,field,searchField,baseUrl,weight,contentType,RESPONSE=None):
Line 170  def manage_addECHO_sqlElement(self,id,ti Line 322  def manage_addECHO_sqlElement(self,id,ti
         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()),
                                        'html/ECHO_pageTemplateDefault.html')                                         'html/ECHO_pageTemplateDefault.html')
   
     manage_options=ZopePageTemplate.manage_options+(      manage_options=ZopePageTemplate.manage_options+ECHO_basis.manage_options+(
         {'label':'Weight and Type','action':'changeECHO_pageTemplateWeightForm'},          {'label':'Main Config','action':'changeECHO_pageTemplateMainForm'},
           {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         )          )
   
     def changeECHO_pageTemplateWeightForm(self):      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"""          """change"""
         pt=PageTemplateFile('Products/ECHO_content/zpt/ChangeECHO_pageTemplateWeight.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeECHO_pageTemplateMain.zpt')).__of__(self)
         return pt()          return pt()
   
     def changeECHO_pageTemplateWeight(self,weight,contentType,label,RESPONSE=None):      def changeECHO_pageTemplateMain(self,weight,contentType,label,description,RESPONSE=None,isAlwaysClickable=None,suffix=None,prefix=None):
         """change"""          """change"""
         self.weight=weight          self.weight=weight
         self.contentType=contentType          self.contentType=contentType
         self.label=label          self.label=label
           self.description=description
           self.isAlwaysClickable=isAlwaysClickable
           self.suffix=suffix
           self.prefix=prefix
                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def getLabel(self):  
         if hasattr(self,'label'):  
             return self.label.encode('utf-8')  
         else:  
             return 0  
           
     def getWeight(self):      def getWeight(self):
         """get weight"""          """get weight"""
         if hasattr(self,'weight'):          if hasattr(self,'weight'):
Line 209  class ECHO_pageTemplate(ZopePageTemplate Line 375  class ECHO_pageTemplate(ZopePageTemplate
             return 0              return 0
                   
     def getcontentType(self):      def getcontentType(self):
         """get weight"""          """get contentType"""
         if hasattr(self,'weight'):          if hasattr(self,'contentType'):
             return self.weight              return self.contentType
         else:          else:
             return 0              return 0
   
Line 227  class ECHO_pageTemplate(ZopePageTemplate Line 393  class ECHO_pageTemplate(ZopePageTemplate
   
 def manage_addECHO_pageTemplateForm(self):  def manage_addECHO_pageTemplateForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/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
Line 259  def manage_addECHO_pageTemplate(self, id Line 425  def manage_addECHO_pageTemplate(self, id
         self._setObject(id, zpt)          self._setObject(id, zpt)
         ob = getattr(self, id)          ob = getattr(self, id)
         setattr(ob,'weight',weight)          setattr(ob,'weight',weight)
           setattr(ob,'label',label)
         if title:          if title:
             ob.pt_setTitle(title)              ob.pt_setTitle(title)
                   
Line 276  def manage_addECHO_pageTemplate(self, id Line 443  def manage_addECHO_pageTemplate(self, id
 class ECHO_navigation(Folder):  class ECHO_navigation(Folder):
     """Navigations Element"""      """Navigations Element"""
     meta_type="ECHO_Navigation"      meta_type="ECHO_Navigation"
       management_page_charset="utf-8"
   
     displayedMetaTypes=displayTypes      def getUsername(self):
           """get name of user"""
           username=str(self.REQUEST['AUTHENTICATED_USER'])
           if username=='Anonymous User':
               return None
           else:
               return username
           
       def searchExternalCollection(self,url,simpleSearch):
           """search external collection via xmlrpc"""
           server=xmlrpclib.Server(url)
           
           results=server.getSubcolsXMLRpc(simpleSearch)
           
           return results
       
       def getXMLRpcConnection(self,url):
           """getxmlrpc"""
           if not hasattr(self,"_v_server"):
               self._v_server=[]
           
           server=xmlrpclib.Server(url)
           self._v_server.append(server)
           
           return len(self._v_server)-1
       
       def getXMLRpcMethod(self,nr,method,compressed=None):
           """getmethod"""
           
           ret= eval('self._v_server[%i].%s'%(nr,method))
           if compressed:
               ret=decodeRPC(ret)
           return ret
       
       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"""
           return unicodify(str)
   
       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/zpt/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')
Line 308  class ECHO_navigation(Folder): Line 600  class ECHO_navigation(Folder):
         #print "HERE",obj.          #print "HERE",obj.
         for x_objs in obj.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes):          for x_objs in obj.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes):
             x=x_objs[1]              x=x_objs[1]
             if checkOnly=="no":              if checkOnly=="yes":
                 x = checkOnlyOneInGroup(x)                  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)
Line 322  class ECHO_navigation(Folder): Line 614  class ECHO_navigation(Folder):
         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  
   
           #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)]
                   
         for keys in obj.__dict__.keys():          # if not generate new hash
             x=getattr(obj,keys)          obj=objtemp      
             if hasattr(x,"meta_type"):  
   
                 if x.meta_type in self.displayedMetaTypes:          for keys in obj.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes):
                                         
               x=keys[1]
                     if depth>1:                      if depth>1:
                         nav[x.getId()]=(self.getColls(x,int(depth)-1,checkOnly),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,sortField=None):      def barFromHash(self,hash,start=None,sortField=None,location=None):
         """Erzeuge Navigations Element"""          """Erzeuge Navigations Element"""
         #print "hash",hash                  
         listNav=[]          listNav=[]
         if not start:          if not start:
             temp=hash              temp=hash
             sortField="weight"              sortField="weight"
         else: # list mit pfad zum hash          else: # liste mit pfad zum hash
             temp=hash              temp=hash
             #print "HI",sortField              #print "HI",sortField
             if not sortField:              if not sortField:
                 tempObj=self.pathToHierarchy[0:]                  tempObj=self.pathToHierarchy[0:]
                 tempObj=re.sub("/",".",tempObj)                  tempObj=re.sub("/",".",tempObj)
                 tempObj="self.aq_parent"+tempObj                  tempObj="self.aq_parent"+tempObj
                   #print tempObj
                 objtemp=eval(tempObj)                  objtemp=eval(tempObj)
   
                 obj=objtemp                  obj=objtemp
Line 381  class ECHO_navigation(Folder): Line 687  class ECHO_navigation(Folder):
             #print "TEMP",temp,self.tempSorted(temp, field=sortField)              #print "TEMP",temp,self.tempSorted(temp, field=sortField)
   
         for x in self.tempSorted(temp, field=sortField):          for x in self.tempSorted(temp, field=sortField):
              
             if not temp[x][1].title == "":              if not temp[x][1].title == "":
                 if temp[x][1].meta_type=="ECHO_sqlElement":                  
                   if (temp[x][1].meta_type=="ECHO_sqlElement") or (temp[x][1].meta_type=="ECHO_ZCatalogElement"):
   
                     for z in temp[x][1].getNavList():                      for z in temp[x][1].getNavList():
                         listNav.append((z[0],z[1],None))                          listNav.append((z[0],z[1],None,'',''))
               
                 else:                  else:
                     # add label fals existiert und nicht leer                      # add label falls existiert und nicht leer
                     if hasattr(temp[x][1],'label'):                      if hasattr(temp[x][1],'label'):
                         if not temp[x][1].label=='':  
                             label=temp[x][1].label.encode('utf-8')  
                                                           
                           if not temp[x][1].getLabel()=='':
                                   label=temp[x][1].getLabel()
                         else:                          else:
                             label=temp[x][1].title.encode('utf-8')                              try:
                                   label=temp[x][1].getTitle()
                               except:
                                   logger("ECHO_Nav",logging.ERROR,"%s has neither getLabel nor getTile implemented"%temp[x][1].getId())
                                   label=""
                     else:                      else:
                         label=temp[x][1].title.encode('utf-8')                                                      label=temp[x][1].getTitle()
   
                                           
                     listNav.append((label,createPath(self.absolute_url(),temp[x][1].absolute_url()),temp[x][1]))                      if location:
                                           
         #print self.getId(),start                          loc=getattr(temp[x][1],'location','top')
         #print listNav                          if (loc==location):
   
         #html=""  
         #for k in listNav:  
         #    print k  
         #    html=html+"<a href='%s'>%s</a>   "% (self.absolute_url()+createPath(k[1][1].absolute_url()),k[0])  
   
                               listNav.append((label,createPath(self,self.absolute_url(),temp[x][1].absolute_url(relative=1))+getattr(temp[x][1],'queryString',''),temp[x][1],getattr(temp[x][1],'prefix',''),getattr(temp[x][1],'suffix','')))
                       else:
                           
                           listNav.append((label,createPath(self,self.absolute_url(),temp[x][1].absolute_url(relative=1))+getattr(temp[x][1],'queryString',''),temp[x][1],getattr(temp[x][1],'prefix',''),getattr(temp[x][1],'suffix','')))
           #print self.REQUEST
         return listNav          return listNav
   
     def tempSorted(self,hash,field="weight"):      def tempSorted(self,hash,field="weight"):
Line 414  class ECHO_navigation(Folder): Line 730  class ECHO_navigation(Folder):
         for x in hash.keys():          for x in hash.keys():
             #print hash[x][1]              #print hash[x][1]
             if hasattr(hash[x][1],field):              if hasattr(hash[x][1],field):
                   try:
                       weight=int(getattr(hash[x][1],field))
                   except:
                 weight=getattr(hash[x][1],field)                  weight=getattr(hash[x][1],field)
                 #print weight                  #print weight
             else:              else:
Line 430  class ECHO_navigation(Folder): Line 749  class ECHO_navigation(Folder):
                           
     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',''))
       
       if len(item)<2:
           return 0
           #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 470  class ECHO_navigation(Folder): Line 825  class ECHO_navigation(Folder):
                           
             description=temp[x][1].title              description=temp[x][1].title
                     
             url=createPath(self.absolute_url(),temp[key][1].absolute_url())              
               url=createPath(self,self.absolute_url(),temp[key][1].absolute_url(relative=1))
   
             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 493  class ECHO_navigation(Folder): Line 849  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()          #print "NAVELEMENT",self.getId()
         #try:          #try:
               
         keys=self.barFromHash(self.createNavHash(0))          keys=self.barFromHash(self.createNavHash(0),location=location)
                   
         #except:          #except:
         #    keys=""          #    keys=""
Line 511  class ECHO_navigation(Folder): Line 867  class ECHO_navigation(Folder):
   
     return len(self.barFromHash(self.createNavHash(0)))       return len(self.barFromHash(self.createNavHash(0))) 
   
       def startOfHierarchy(self,list):
           splitted=self.pathToHierarchy.split("/")
           last=splitted[len(splitted)-1]
           #print last,list
           try:
               nr=list.index(last)
           except:
               nr=0
           return nr+1
       
       def subNavStatic(self,obj):
           """subnav" von self"""
           def sortWeight(x,y):
               x1=int(getattr(x[1],'weight','0'))
               y1=int(getattr(y[1],'weight','0'))
               return cmp(x1,y1)
           print "obj",obj
           subs=self.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes)
           subret=[]
           
           for x in subs:
               if not(x[1].title==""):
                   subret.append(x)
           subret.sort(sortWeight)
           return subret
       
     def secondNavElements(self):      def secondNavElements(self):
         """Zweite Ordnung"""          """Zweite Ordnung Navigationselemente"""
           
           hash=self.createNavHash(2,checkOnly="no")
                   
         hash=self.createNavHash(2,checkOnly="yes")  
         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 522  class ECHO_navigation(Folder): Line 905  class ECHO_navigation(Folder):
   
         splitted=ult_temp.split("/")          splitted=ult_temp.split("/")
                   
           #print "AU",self.absolute_url(),splitted
           #start=[splitted[2]] #orig
           startNr= self.startOfHierarchy(splitted)
           
           start=[splitted[startNr]]
   
         start=[splitted[2]]  
         #print start          #print start
                 
         keys=self.barFromHash(hash,start=start)          keys=self.barFromHash(hash,start=start)
Line 548  class ECHO_navigation(Folder): Line 935  class ECHO_navigation(Folder):
 ##         else:  ##         else:
 ##             start=[splitted[len(splitted)-1]]  ##             start=[splitted[len(splitted)-1]]
   
         start=splitted[2:order+1]          #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 584  class ECHO_navigation(Folder): Line 974  class ECHO_navigation(Folder):
   
 def manage_addECHO_navigationForm(self):  def manage_addECHO_navigationForm(self):
     """Form for adding"""      """Form for adding"""
     pt=PageTemplateFile('Products/ECHO_content/zpt/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):
Line 599  def manage_addECHO_navigation(self,id,ti Line 989  def manage_addECHO_navigation(self,id,ti
   
   
   
 def createPath(url1,url2):  def createPath(self,url1,url2):
       #bugfix in absolute_url, ploetzlich erschein in absolute_url der physikalische pfad.
       
       if self.REQUEST.has_key('VirtualRootPhysicalPath'):
           vp="/".join(self.REQUEST['VirtualRootPhysicalPath'])
           if (len(vp)>0):
               if vp[0]=="/":
                   vp=vp[1:]
           
               url2=url2.replace(vp+"/",'')
       else:
     temp1=url1.split("/")      temp1=url1.split("/")
     temp2=url2.split("/")      temp2=url2.split("/")
     for test in temp1:      for test in temp1:
         if temp2[0]==test:          if temp2[0]==test:
             del temp2[0]              del temp2[0]
   
     return url1+"/"+string.join(temp2,"/")          url2= string.join(temp2,"/")
           
       return url1+"/"+url2
   
 def sortWeight(x,y):  def sortWeight(x,y):
     #print x[1],y[1]      #print x[1],y[1]
Removed from v.1.21  
changed lines
  Added in v.1.81

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