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