File:  [Repository] / ECHO_content / ECHO_Nav.py
Revision 1.59: download - view: text, annotated - select for diffs - revision graph
Sun Oct 23 09:46:26 2005 UTC (18 years, 7 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
echo xslt neu

    1: # Objekte zur Erzeugung von Navigationselementen
    2: 
    3: from AccessControl import ClassSecurityInfo
    4: from Globals import DTMLFile
    5: from OFS.Image import Image,cookId
    6: from OFS.Folder import Folder
    7: from OFS.SimpleItem import SimpleItem
    8: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    9: from Products.PageTemplates.PageTemplate import PageTemplate
   10: import re
   11: import string
   12: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   13: import os.path
   14: from Globals import package_home
   15: import urllib
   16: from ECHO_helpers import *
   17: from ECHO_collection import content_html 
   18: from types import *
   19: 
   20: 
   21: from Globals import DTMLFile
   22: from OFS.Image import Image,cookId
   23: from OFS.Folder import Folder
   24: from OFS.SimpleItem import SimpleItem
   25: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   26: from Products.PageTemplates.PageTemplate import PageTemplate
   27: import re
   28: import string
   29: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   30: import os.path
   31: 
   32: import urllib
   33: from ECHO_helpers import displayTypes,checkOnlyOneInGroup
   34: from ECHO_collection import content_html
   35: import zLOG
   36: 
   37: try:    
   38:     from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
   39: except:
   40:     zLOG.LOG('ECHO_Nav',zLOG.INFO,'ZSQLSimpleSearch not supported')
   41: 
   42: 
   43: 
   44: class ECHO_ZCatalogElement(SimpleItem):
   45:     """Erzeuge navigation aus ZCatalog-abfrage"""
   46:     meta_type="ECHO_ZCatalogElement"
   47:     baseUrl=""
   48: 
   49:     def __init__(self,id,title,field,catalogId,baseUrl,weight,contentType):
   50:         """init"""
   51:         self.id=id
   52:         self.title=title
   53:         self.catalogId=catalogId
   54:         self.field=field
   55: 
   56:         self.baseUrl=baseUrl
   57:         self.weight=weight
   58:         self.content=contentType
   59: 
   60:         
   61:     manage_options= SimpleItem.manage_options+(
   62:         {'label':'Main Config','action':'changeECHO_ZCatalogElementForm'},
   63:         )
   64: 
   65:         
   66:     def getWeight(self):
   67:         """get weight"""
   68:         if hasattr(self,'weight'):
   69:             return self.weight
   70:         else:
   71:             return 0
   72:         
   73:     def getcontentType(self):
   74:         """get weight"""
   75:         
   76:         if hasattr(self,'contentType'):
   77:             return self.contentType
   78:         else:
   79:             return 0
   80:         
   81: 
   82:     def changeECHO_ZCatalogElementForm(self):
   83:         """change"""
   84:         
   85:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHO_ZCatalogElement.zpt')).__of__(self)
   86:         return pt()
   87: 
   88:     def changeECHO_ZCatalogElement(self,title,field,catalogId,baseUrl,weight,contentType,RESPONSE=None):
   89:         """change"""
   90:         self.title=title
   91:         self.catalogId=catalogId
   92:         self.field=field
   93:         self.baseUrl=baseUrl
   94:         self.weight=weight
   95:         self.contentType=contentType
   96:         
   97:         if RESPONSE is not None:
   98:             RESPONSE.redirect('manage_main')
   99:     def getKeywordList(self):
  100:         return getattr(self,self.catalogId).uniqueValuesFor(self.field)
  101:     
  102:     def getNavList(self):
  103:         """ausgabe der treffer list für navigation"""
  104:         
  105:         records=self.getKeywordList()
  106:         
  107:         
  108:         if not records:
  109:             return []
  110:         else:
  111:             ret=[]
  112:             for record in records:
  113:                 #print "RC",record
  114:                 #if record:
  115:                 #    ret.append((record,self.baseUrl+urllib.quote(record)))
  116:                 try:
  117:                     ret.append((record,self.baseUrl+urllib.quote(record)))
  118:                 except:
  119:                     """nothing"""
  120:                     
  121:             return ret
  122:     
  123: 
  124: def manage_addECHO_ZCatalogElementForm(self):
  125:     """Form for adding"""
  126:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_ZCatalogElement.zpt')).__of__(self)
  127:     return pt()
  128: 
  129: def manage_addECHO_ZCatalogElement(self,id,title,field,baseUrl,weight,contentType,RESPONSE=None):
  130:     """Add an ECHO_ZCatalogelement"""
  131:     self._setObject(id,ECHO_ZCatalogElement(id,title,field,baseUrl,weight,contentType))
  132:     
  133:     if RESPONSE is not None:
  134:         RESPONSE.redirect('manage_main')
  135: 
  136: 
  137: 
  138: class ECHO_contentType(Image):
  139:     """ContentType Object"""
  140: 
  141:     meta_type="ECHO_contentType"
  142: 
  143:     
  144:     manage_options=Image.manage_options+(
  145:         {'label':'Change Description','action':'changeECHO_contentTypeForm'},
  146:        )
  147: 
  148:     def changeECHO_contentTypeForm(self):
  149:         """Change the description text"""
  150:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHO_contentType.zpt')).__of__(self)
  151:         return pt()
  152:  
  153:     def changeECHO_contentType(self,description,RESPONSE=None):
  154:         """Change the Content"""
  155:         self.description=description
  156:         if RESPONSE is not None:
  157:             RESPONSE.redirect('manage_main')
  158: 
  159: manage_addECHO_contentTypeForm=DTMLFile('dtml/ECHO_contentTypeAdd',globals(),
  160:                              Kind='ECHO_contentType',kind='ECHO_contentType')
  161: 
  162: def manage_addECHO_contentType(self, id, file=None, title='', precondition='', content_type='', description='',
  163:                     REQUEST=None):
  164:     """
  165:     Add a new Image object.
  166: 
  167:     Creates a new Image object 'id' with the contents of 'file'.
  168:     """
  169: 
  170:     id=str(id)
  171:     title=str(title)
  172:     content_type=str(content_type)
  173:     precondition=str(precondition)
  174: 
  175:     id, title = cookId(id, title, file)
  176: 
  177:     self=self.this()
  178: 
  179:     # First, we create the image without data:
  180:     self._setObject(id, ECHO_contentType(id,title,'',content_type, precondition))
  181: 
  182:     self._getOb(id).description=description
  183:         
  184:     # Now we "upload" the data.  By doing this in two steps, we
  185:     # can use a database trick to make the upload more efficient.
  186:     if file:
  187:         self._getOb(id).manage_upload(file)
  188:     if content_type:
  189:         self._getOb(id).content_type=content_type
  190: 
  191:     if REQUEST is not None:
  192:         try:    url=self.DestinationURL()
  193:         except: url=REQUEST['URL1']
  194:         REQUEST.RESPONSE.redirect('%s/manage_main' % url)
  195:     return id
  196: 
  197: 
  198: class ECHO_sqlElement(SimpleItem):
  199:     """Erzeuge navigation aus sql-abfrage"""
  200:     meta_type="ECHO_sqlElement"
  201:     baseUrl=""
  202: 
  203: 
  204:     
  205:     def __init__(self,id,title,query,field,searchField,baseUrl,weight,contentType):
  206:         """init"""
  207:         self.id=id
  208:         self.title=title
  209:         self.query=query
  210:         self.field=field
  211:         if searchField=="":
  212:             self.searchField=field
  213:         else:
  214:             self.searchField=searchField
  215:         self.baseUrl=baseUrl
  216: 
  217:         self.content=contentType
  218: 
  219:     manage_options= SimpleItem.manage_options+(
  220:         {'label':'Main Config','action':'changeECHO_sqlElementForm'},
  221:         )
  222: 
  223:     def getSearchField(self):
  224:         try:
  225:             return self.searchField
  226:         except:
  227:             return self.field
  228:         
  229:     def getWeight(self):
  230:         """get weight"""
  231:         if hasattr(self,'weight'):
  232:             return self.weight
  233:         else:
  234:             return 0
  235:         
  236:     def getcontentType(self):
  237:         """get weight"""
  238:         
  239:         if hasattr(self,'contentType'):
  240:             return self.contentType
  241:         else:
  242:             return 0
  243:         
  244: 
  245:     def changeECHO_sqlElementForm(self):
  246:         """change"""
  247:         
  248:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeECHO_sqlElement.zpt')).__of__(self)
  249:         return pt()
  250: 
  251:     def changeECHO_sqlElement(self,title,query,field,searchField,baseUrl,weight,contentType,RESPONSE=None):
  252:         """change"""
  253:         self.title=title
  254:         self.query=query
  255:         self.field=field
  256:         self.searchField=searchField
  257:         self.baseUrl=baseUrl
  258:         self.weight=weight
  259:         self.contentType=contentType
  260:         
  261:         if RESPONSE is not None:
  262:             RESPONSE.redirect('manage_main')
  263: 
  264:     try:    
  265:         searchQuery=ZSQLExtendFolder.ZSQLSimpleSearch
  266:     except:
  267:         zLOG.LOG('ECHO_Nav',zLOG.INFO,'ZSQLSimpleSearch not supported')
  268:             
  269:     def getNavList(self): 
  270:         """ausgabe der treffer list für navigation"""
  271:         
  272:         records=self.searchQuery()
  273:       
  274:         
  275:         if not records:
  276:             return []
  277:         else:
  278:             ret=[]
  279:             for record in records:
  280:                 try:
  281:                     ret.append((getattr(record,self.field),self.baseUrl+urllib.quote(str(getattr(record,self.getSearchField())))))
  282:                 except:
  283:                     """notrhing"""
  284:                     
  285:             return ret
  286:     
  287: 
  288: def manage_addECHO_sqlElementForm(self):
  289:     """Form for adding"""
  290:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_sqlElement.zpt')).__of__(self)
  291:     return pt()
  292: 
  293: def manage_addECHO_sqlElement(self,id,title,query,field,searchField,baseUrl,weight,contentType,RESPONSE=None):
  294:     """Add an ECHO_sqlelement"""
  295:     self._setObject(id,ECHO_sqlElement(id,title,query,field,searchField,baseUrl,weight,contentType))
  296:     
  297:     if RESPONSE is not None:
  298:         RESPONSE.redirect('manage_main')
  299: 
  300: 
  301: class ECHO_pageTemplate(ZopePageTemplate,ECHO_basis):
  302:     """pageTemplate Objekt"""
  303:     meta_type="ECHO_pageTemplate"
  304:     security=ClassSecurityInfo()
  305:     
  306:     
  307:     _default_content_fn = os.path.join(package_home(globals()),
  308:                                        'html/ECHO_pageTemplateDefault.html')
  309: 
  310:     manage_options=ZopePageTemplate.manage_options+ECHO_basis.manage_options+(
  311:         {'label':'Main Config','action':'changeECHO_pageTemplateMainForm'},
  312:         {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
  313:         )
  314: 
  315:     security.declarePublic('content_html')
  316: 
  317:     def addChanges(self):
  318:         """do nothing leere methode, notwendig, da bei veerbung 
  319:         von dieser klasse nur ueberschrieben werden kann, 
  320:         falls methode per url aufgerufen werden soll"""
  321:         
  322:         return True
  323:     
  324:     def content_html(self):
  325:         """content_html"""
  326:         return content_html(self,'pageTemplate')
  327: 
  328:     def changeECHO_pageTemplateMainForm(self):
  329:         """change"""
  330:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeECHO_pageTemplateMain.zpt')).__of__(self)
  331:         return pt()
  332: 
  333:     def changeECHO_pageTemplateMain(self,weight,contentType,label,description,RESPONSE=None,isAlwaysClickable=None,suffix=None,prefix=None):
  334:         """change"""
  335:         self.weight=weight
  336:         self.contentType=contentType
  337:         self.label=label
  338:         self.description=description
  339:         self.isAlwaysClickable=isAlwaysClickable
  340:         self.suffix=suffix
  341:         self.prefix=prefix
  342:         
  343:         if RESPONSE is not None:
  344:             RESPONSE.redirect('manage_main')
  345:      
  346:     def getWeight(self):
  347:         """get weight"""
  348:         if hasattr(self,'weight'):
  349:             return self.weight
  350:         else:
  351:             return 0
  352:         
  353:     def getcontentType(self):
  354:         """get contentType"""
  355:         if hasattr(self,'contentType'):
  356:             return self.contentType
  357:         else:
  358:             return 0
  359: 
  360: 
  361: 
  362: 
  363:     ## def __init__(self, id, text=None, contentType=None):
  364: ##         self.id = str(id)
  365: ##         self.ZBindings_edit(self._default_bindings)
  366: ##         if text is None:
  367: ##             text = open(self._default_cont).read()
  368: ##         self.pt_edit(text, contentType)
  369: 
  370: def manage_addECHO_pageTemplateForm(self):
  371:     """Form for adding"""
  372:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_pageTemplate.zpt')).__of__(self)
  373:     return pt()
  374: 
  375: from urllib import quote
  376: 
  377: 
  378: def manage_addECHO_pageTemplate(self, id, label, weight= 0,contentType=0,title=None, text=None,
  379:                            REQUEST=None, submit=None):
  380:     "Add a Page Template with optional file content."
  381: 
  382:     
  383:     id = str(id)
  384:     if REQUEST is None:
  385:         self._setObject(id, ECHO_pageTemplate(id, text))
  386:         ob = getattr(self, id)
  387:         setattr(ob,'weight',weight)
  388:         setattr(ob,'label',label)
  389:         setattr(ob,'contentType',contentType)
  390:         if title:
  391:             ob.pt_setTitle(title)
  392:         return ob
  393:     else:
  394:         file = REQUEST.form.get('file')
  395:         headers = getattr(file, 'headers', None)
  396:         if headers is None or not file.filename:
  397:             zpt = ECHO_pageTemplate(id)
  398:         else:
  399:             zpt = ECHO_pageTemplate(id, file, headers.get('contentType'))
  400: 
  401:         self._setObject(id, zpt)
  402:         ob = getattr(self, id)
  403:         setattr(ob,'weight',weight)
  404:         setattr(ob,'label',label)
  405:         if title:
  406:             ob.pt_setTitle(title)
  407:         
  408:         try:
  409:             u = self.DestinationURL()
  410:         except AttributeError:
  411:             u = REQUEST['URL1']
  412: 
  413:         if submit == " Add and Edit ":
  414:             u = "%s/%s" % (u, quote(id))
  415:         REQUEST.RESPONSE.redirect(u+'/manage_main')
  416:     return ''
  417: 
  418: 
  419: class ECHO_navigation(Folder):
  420:     """Navigations Element"""
  421:     meta_type="ECHO_Navigation"
  422: 
  423:     def getNavInfo(self):
  424:         """root informationen"""
  425:         if hasattr(self,'logo_image'):
  426:             if hasattr(self.logo_image,'tag'):
  427:                 imageTag=self.logo_image.tag()
  428:         else:
  429:             imageTag=''
  430:         return (self.title,imageTag)
  431: 
  432:     def linkBar(self,parent):
  433:         """linkbarer balken"""
  434:         str=""
  435: 
  436:         
  437:         while not(parent.meta_type == "ECHO_root"):
  438:             fragment="""<a href="%s">%s</a>"""%(parent.absolute_url(),parent.label)
  439:             str=fragment+"/"+str
  440:             parent=parent.aq_parent
  441: 
  442:         return str
  443:     
  444:     def decode(self,str):
  445:         """decoder"""
  446:         if not str:
  447:             return ""
  448:         if type(str)==StringType:
  449:             
  450:             return str
  451:         else:
  452:             try:
  453:                 return str.encode('utf-8')
  454:             except:
  455:                 return str.encode('latin-1')
  456:     def ECHOFormatListStr(self,list,search="\n",replace="<br>"):
  457:         """formatiert liste im str"""
  458:         if list:
  459:                 return re.sub(search,replace,list)
  460:         else:
  461:                 return 
  462: 
  463:     def ECHO_cacheManageForm(self):
  464:             """change form"""
  465:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ECHO_cacheManageForm')).__of__(self)
  466:             pt.content_type="text/html"
  467:             return pt()
  468: 
  469:     def ECHO_cacheManage(self,cacheManagerName=None,deleteCache=None, activateCache=None,RESPONSE=None):
  470:             """cachemanager"""
  471:             if cacheManagerName=="": chacheManagerName=None
  472:             
  473:             self.cacheManagerName=cacheManagerName
  474:             self.setCache(managerName=cacheManagerName)
  475:             
  476:             if deleteCache:
  477:                 try:
  478:                     self.deleteCache()
  479:                 except:
  480:                     for roots in self.ZopeFind(self,obj_metatypes=['ECHO_root'],search_sub=1):
  481:                         roots[1].deleteCache()
  482:                     
  483: 
  484:             self.activateCache=activateCache
  485: 
  486:             if RESPONSE is not None:
  487:                     RESPONSE.redirect('manage_main')
  488:         
  489:     def setCache(self,obj=None,RESPONSE=None,managerName='CacheManager'):
  490:         """setze alle collections auf cache = CacheManager"""
  491: 
  492: 
  493:         if not obj:
  494:             obj = self
  495:             
  496:         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_collection','VLP_resource'],search_sub=1)
  497: 
  498:         for entry in entries:
  499:             entry[1].ZCacheable_setManagerId(managerName)
  500: 
  501:         
  502:         return "changed all CM in: "+self.title
  503: 
  504:     
  505: 
  506:     displayableMetaTypes=displayTypes
  507:     
  508:     def getImageViewers(self):
  509:         """images"""
  510:         viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])
  511:         return viewers
  512:     
  513:     def getR(self):
  514:         """re"""
  515:         return self.REQUEST
  516: 
  517:     def __init__(self,id,title,pathToHierarchy):
  518:         """init"""
  519:         self.id=id
  520:         self.title=title
  521:         self.pathToHierarchy=pathToHierarchy
  522:         self.displayedMetaTypes=displayTypes
  523:         
  524:     manage_options = Folder.manage_options+(
  525:         {'label':'Main Config','action':'ECHO_navigationConfigForm'},
  526:         {'label':'Cache','action':'ECHO_cacheManageForm'},
  527: 
  528:         )
  529:     displayedMetaTypes=displayTypes
  530:     
  531:     def ECHO_navigationConfigForm(self):
  532:         """configForm"""
  533:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ChangeECHO_navigation.zpt')).__of__(self)
  534:         return pt()
  535:     
  536:     def ECHO_navigationConfig(self,title,pathToHierarchy,displayedMetaTypes=displayTypes,RESPONSE=None):
  537:         """config"""
  538:         self.title=title
  539:         self.pathToHierarchy=pathToHierarchy
  540:         self.displayedMetaTypes=toList(displayedMetaTypes)[0:]
  541: 
  542: 
  543:         if RESPONSE is not None:
  544:             RESPONSE.redirect('manage_main')
  545: 
  546: 
  547:     def getColls(self,obj,depth,checkOnly="no"):
  548:         nav={}
  549:         #print "HERE",obj.
  550:         for x_objs in obj.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes):
  551:             x=x_objs[1]
  552:             if checkOnly=="yes":
  553:                 x = checkOnlyOneInGroup(x)
  554:             if depth>1:
  555:                 nav[x.getId()]=(self.getColls(x,depth-1),x)
  556:             else:
  557:                 nav[x.getId()]=(None,x)
  558:         return nav
  559:     
  560:     def createNavHash(self,depth,checkOnly="no"):
  561:         """Auslesen des Hierarchiebuames"""
  562:         temp=self.pathToHierarchy[0:]
  563:         temp=re.sub("/",".",temp)
  564:         temp="self.aq_parent"+temp
  565: 
  566:         
  567:         objtemp=eval(temp)
  568:         nav={}
  569:         
  570:         #check if cash is enabled and if already exists and if not empty
  571:         if getattr(self,'_v_hash',None) and getattr(self,'activateCache',None) and self._v_hash.get(str(depth),None):
  572:            
  573:            return self._v_hash[str(depth)]
  574: 
  575:         # if not generate new hash
  576:         obj=objtemp      
  577: 
  578:         for keys in obj.ZopeFind(obj,obj_metatypes=self.displayedMetaTypes):
  579:             x=keys[1]
  580:             if depth>1:
  581:                 nav[x.getId()]=(self.getColls(x,int(depth)-1,checkOnly),x)
  582:             else:
  583:                 nav[x.getId()]=(None,x)
  584:             
  585:         #store in cache if activated
  586:         if getattr(self,'activateCache',None):
  587:             
  588:             try:
  589:                 self._v_hash[str(depth)]={}
  590:             except:
  591:                 self._v_hash={}
  592:                 self._v_hash[str(depth)]={}
  593: 
  594:             for x in nav.keys():
  595:                 self._v_hash[str(depth)][x]=nav[x]
  596: 
  597:         return nav
  598: 
  599:     def barFromHash(self,hash,start=None,sortField=None,location=None):
  600:         """Erzeuge Navigations Element"""
  601:         #print "hash",hash
  602:         listNav=[]
  603:         if not start:
  604:             temp=hash
  605:             sortField="weight"
  606:         else: # liste mit pfad zum hash
  607:             temp=hash
  608:             #print "HI",sortField
  609:             if not sortField:
  610:                 tempObj=self.pathToHierarchy[0:]
  611:                 tempObj=re.sub("/",".",tempObj)
  612:                 tempObj="self.aq_parent"+tempObj
  613:                 #print tempObj
  614:                 objtemp=eval(tempObj)
  615: 
  616:                 obj=objtemp
  617: 
  618:                 for x in start:
  619:                     #print "OBJ",start,obj,obj.getId(),x
  620: 
  621:                     obj=getattr(obj,x)
  622: 
  623:                 if hasattr(obj,'sortfield'):
  624:                     sortField=obj.sortfield
  625:                 else:
  626:                     sortField='weight'
  627:             #print "START",start
  628:             for x in start:
  629:                 #print "N2",x,temp[x]
  630:                 try:
  631:                     temp=temp[x][0]
  632:                 except:
  633:                     """nothing"""
  634:                     return []
  635:             #print "TEMP",temp,self.tempSorted(temp, field=sortField)
  636: 
  637:         for x in self.tempSorted(temp, field=sortField):
  638:             
  639:             if not temp[x][1].title == "":
  640:                 
  641:                 if (temp[x][1].meta_type=="ECHO_sqlElement") or (temp[x][1].meta_type=="ECHO_ZCatalogElement"):
  642:             
  643:                     for z in temp[x][1].getNavList():
  644:                         listNav.append((z[0],z[1],None,'',''))
  645:             
  646:                 else:
  647:                     # add label falls existiert und nicht leer
  648:                     if hasattr(temp[x][1],'label'):
  649:                         
  650:                         if not temp[x][1].label=='':
  651:                             try:
  652:                                 label=temp[x][1].getLabel()
  653:                             except:
  654:                                 label=temp[x][1].label
  655:                         else:
  656:                             label=temp[x][1].title.encode('utf-8')
  657:                     else:
  658:                         label=temp[x][1].title.encode('utf-8')                            
  659:                     
  660:                     if location:
  661: 
  662:                         loc=getattr(temp[x][1],'location','top')
  663:                         if (loc==location):
  664:                             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','')))
  665:                     else:
  666:                         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','')))
  667: 
  668:         return listNav
  669: 
  670:     def tempSorted(self,hash,field="weight"):
  671:         ls=[]
  672: 
  673:         for x in hash.keys():
  674:             #print hash[x][1]
  675:             if hasattr(hash[x][1],field):
  676:                 try:
  677:                     weight=int(getattr(hash[x][1],field))
  678:                 except:
  679:                     weight=getattr(hash[x][1],field)
  680:                 #print weight
  681:             else:
  682:                 weight=0
  683: 
  684:             ls.append((x,weight))
  685: 
  686:         ls.sort(sortWeight)
  687:         
  688:         return [x[0] for x in ls]
  689: 
  690:     
  691:         
  692:             
  693:     def isSelectedPath(self,item):
  694:         """test is path is already selected"""
  695: 
  696:         testStr=re.sub("/index_html",'',self.REQUEST.get('URL',''))
  697: 
  698:         #falls exakte Übereinstimmung dann immer 1
  699:         if (testStr==item[1]) and (self.REQUEST.get('QUERY_STRING','')==''):
  700:             
  701:             return 1
  702:            
  703:         found=re.search("\?(.*)",item[1])
  704:         
  705:         if found:
  706:             temp=re.sub(" ","%20",found.group(0))
  707:           
  708:             #print temp+"::"+self.REQUEST['QUERY_STRING']
  709:             if ("?"+self.REQUEST['QUERY_STRING'])==temp:
  710:                 if getattr(item[2],'isAlwaysClickable',None): #immer auswaehlbar?
  711:                 
  712:                     return 2
  713:                 else:
  714:                     return 1
  715: 
  716:         if (getattr(item[2],'meta_type','')=="ECHO_pageTemplate") and (re.search(item[1],self.REQUEST['URL'])):
  717:             if getattr(item[2],'isAlwaysClickable',None): #immer auswaehlbar?
  718:                 
  719:                 return 2
  720:             else:
  721:                 return 1
  722: 
  723:         if re.search(item[1]+"/",self.REQUEST['URL']):
  724:             if getattr(item[2],'isAlwaysClickable',None): #immer auswaehlbar?
  725:                 
  726:                 return 2
  727:             else:
  728:                 return 1
  729:         else:
  730:             return 0
  731:     
  732: 
  733:     def getPathStyle(self, item, style=""):
  734:         """returns a string with the given style + 'sel' if the path is already selected."""
  735: 
  736:         if self.isSelectedPath(item):
  737:             return style + 'sel'
  738:         else:
  739:             return style
  740:         
  741:     
  742:     def buttonsFromHash(self,hash,start=None,orientation="horizontal"):
  743:         
  744:         """Generate Buttons"""
  745:         if orientation=="horizontal":
  746:             html="<table><tr>"
  747:             startTag="<td>"
  748:             endTag="</td>"
  749:             endHtml="</tr></table>"
  750: 
  751:         else:
  752:             html="<table>"
  753:             startTag="<tr><td>"
  754:             endTag="</td></tr>"
  755:             endHtml="</table>"
  756:             
  757:         if not start:
  758:             temp=hash
  759:         else:
  760:             temp=hash
  761:             for x in start:
  762:                 temp=temp[x][0]
  763:                 #print temp
  764:         
  765:         for key in self.tempSorted(temp):
  766:             
  767:             description=temp[x][1].title
  768:          
  769:             url=createPath(self.absolute_url(),temp[key][1].absolute_url())
  770: 
  771:             if (self.REQUEST['URL']==url) | (self.REQUEST['URL']==url+"/index_html"):
  772:                 html=html+startTag+"[%s]" % description+endTag
  773:             else:                
  774:                 html=html+startTag+"[<a href='%s'>%s</a>]" % (url,description)+endTag
  775:             
  776: 
  777:         html=html+endHtml
  778:         
  779:         return html
  780: 
  781:     def mainNavBar(self):
  782:         """print main navigation bar"""
  783:         keys=""
  784: 
  785:         try:
  786:             keys=self.buttonsFromHash(self.createNavHash(0))
  787:         except:
  788:             keys=""
  789:             
  790:         return keys
  791: 
  792:     def mainNavElements(self,location=None):
  793:         """print main navigation bar"""
  794:         keys=""
  795:         #print "NAVELEMENT",self.getId()
  796:         #try:
  797:         
  798:         keys=self.barFromHash(self.createNavHash(0),location=location)
  799:         
  800:         #except:
  801:         #    keys=""
  802:             
  803:         return keys
  804: 
  805:     def numberOfMainNavElements(self):
  806:         """number of main elements"""
  807: 
  808:         return len(self.barFromHash(self.createNavHash(0))) 
  809: 
  810:     def startOfHierarchy(self,list):
  811:         splitted=self.pathToHierarchy.split("/")
  812:         last=splitted[len(splitted)-1]
  813:         #print last,list
  814:         try:
  815:             nr=list.index(last)
  816:         except:
  817:             nr=0
  818:         return nr+1
  819:     
  820:     def secondNavElements(self):
  821:         """Zweite Ordnung Navigationselemente"""
  822:         
  823:         hash=self.createNavHash(2,checkOnly="no")
  824:         actual_url=self.REQUEST['URL']
  825:         
  826:         ult_temp=re.sub(self.absolute_url(),"",actual_url)
  827:         #print ult_temp
  828: 
  829:         splitted=ult_temp.split("/")
  830:         
  831:         #print "AU",self.absolute_url(),splitted
  832:         #start=[splitted[2]] #orig
  833:         startNr= self.startOfHierarchy(splitted)
  834:         
  835:         start=[splitted[startNr]]
  836:         
  837:         #print start
  838:        
  839:         keys=self.barFromHash(hash,start=start)
  840:         
  841:         
  842:         return keys
  843: 
  844:     def navElements(self,order):
  845:         """n-te Ordnung"""
  846:         
  847:         hash=self.createNavHash(order)
  848:         actual_url=self.REQUEST['URL']
  849:         
  850:         ult_temp=re.sub(self.absolute_url(),"",actual_url)
  851:         #print ult_temp
  852: 
  853:         splitted=ult_temp.split("/")
  854:         
  855: 
  856:         ## if splitted[len(splitted)-1]=="index_html":
  857: ##             start=[splitted[len(splitted)-2]]
  858: ##         else:
  859: ##             start=[splitted[len(splitted)-1]]
  860: 
  861:         #start=splitted[2:order+1] #orig
  862:         startNr= self.startOfHierarchy(splitted)
  863:         #print startNr
  864:         start=splitted[startNr:order+startNr-1] 
  865:         #print start
  866:        
  867:         keys=self.barFromHash(hash,start=start)
  868:         
  869:         
  870:         return keys
  871: 
  872: 
  873:     def secondNavBar(self):
  874:         """Zweite Ordnung"""
  875: 
  876:         hash=self.createNavHash(2)
  877:         actual_url=self.REQUEST['URL']
  878:         
  879:         ult_temp=re.sub(self.absolute_url(),"",actual_url)
  880:         #print ult_temp
  881: 
  882:         splitted=ult_temp.split("/")
  883:         
  884: 
  885:         ## if splitted[len(splitted)-1]=="index_html":
  886: ##             start=[splitted[len(splitted)-2]]
  887: ##         else:
  888: ##             start=[splitted[len(splitted)-1]]
  889: 
  890:         start=[splitted[2]]
  891:         #print start
  892:         
  893:         keys=self.buttonsFromHash(hash,start=start,orientation="vertical")
  894:         
  895:         
  896:         return keys
  897: 
  898: def manage_addECHO_navigationForm(self):
  899:     """Form for adding"""
  900:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_navigation.zpt')).__of__(self)
  901:     return pt()
  902: 
  903: def manage_addECHO_navigation(self,id,title,pathToHierarchy,RESPONSE=None):
  904:     """Add an ECHO_root"""
  905:     self._setObject(id,ECHO_navigation(id,title,pathToHierarchy))
  906:     
  907:     if RESPONSE is not None:
  908:         RESPONSE.redirect('manage_main')
  909: 
  910: 
  911: #helpers
  912: 
  913: 
  914: 
  915: def createPath(url1,url2):
  916:     temp1=url1.split("/")
  917:     temp2=url2.split("/")
  918:     for test in temp1:
  919:         if temp2[0]==test:
  920:             del temp2[0]
  921: 
  922:     #print "CP:"+url1+"::"+url2+"::"+url1+"/"+string.join(temp2,"/")
  923:     return url1+"/"+string.join(temp2,"/")
  924: 
  925: def sortWeight(x,y):
  926:     #print x[1],y[1]
  927:     return cmp(x[1],y[1])
  928:     

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