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