Annotation of ECHO_content/ECHO_Nav.py, revision 1.5

1.1       dwinter     1: # Objekte zur Erzeugung von Navigationselementen
                      2: 
                      3: 
                      4: from OFS.Folder import Folder
                      5: from OFS.SimpleItem import SimpleItem
                      6: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
                      7: from Products.PageTemplates.PageTemplate import PageTemplate
                      8: import re
                      9: import string
                     10: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
                     11: import os.path
                     12: from Globals import package_home
                     13: import urllib
                     14: 
                     15: class ECHO_sqlElement(SimpleItem):
                     16:     """Erzeuge navigation aus sql-abfrage"""
                     17:     meta_type="ECHO_sqlElement"
                     18:     baseUrl=""
                     19:     
1.3       dwinter    20:     def __init__(self,id,title,query,field,baseUrl,weight):
1.1       dwinter    21:         """init"""
                     22:         self.id=id
                     23:         self.title=title
                     24:         self.query=query
                     25:         self.field=field
                     26:         self.baseUrl=baseUrl
1.3       dwinter    27:         self.weight=weight
1.1       dwinter    28: 
                     29:     manage_options= SimpleItem.manage_options+(
                     30:         {'label':'Main Config','action':'changeECHO_sqlElementForm'},
                     31:         )
                     32: 
1.3       dwinter    33:     def getWeight(self):
1.4       dwinter    34:         """get weight"""
                     35:         if hasattr(self,'weight'):
                     36:             return self.weight
1.3       dwinter    37:         else:
                     38:             return 0
                     39:         
                     40:         
                     41: 
1.1       dwinter    42:     def changeECHO_sqlElementForm(self):
                     43:         """change"""
                     44:         pt=PageTemplateFile('Products/ECHO_content/ChangeECHO_sqlElement.zpt').__of__(self)
                     45:         return pt()
                     46: 
1.3       dwinter    47:     def changeECHO_sqlElement(self,title,query,field,baseUrl,weight,RESPONSE=None):
1.1       dwinter    48:         """change"""
                     49:         self.title=title
                     50:         self.query=query
                     51:         self.field=field
                     52:         self.baseUrl=baseUrl
1.3       dwinter    53:         self.weight=weight
1.1       dwinter    54: 
                     55:         if RESPONSE is not None:
                     56:             RESPONSE.redirect('manage_main')
                     57: 
                     58:     def searchQuery(self):
                     59:         return self.search(var=self.query)
                     60:     
                     61:     def getNavList(self):
                     62:         """ausgabe der treffer list für navigation"""
                     63:         records=self.searchQuery()
                     64:         if not records:
                     65:             return []
                     66:         else:
                     67:             ret=[]
                     68:             for record in records:
                     69:                 ret.append((getattr(record,self.field),self.baseUrl+str(getattr(record,self.field))))
                     70:             return ret
                     71:     
                     72: 
                     73: def manage_AddECHO_sqlElementForm(self):
                     74:     """Form for adding"""
                     75:     pt=PageTemplateFile('Products/ECHO_content/AddECHO_sqlElement.zpt').__of__(self)
                     76:     return pt()
                     77: 
                     78: def manage_AddECHO_sqlElement(self,id,title,query,field,baseUrl,RESPONSE=None):
                     79:     """Add an ECHO_sqlelement"""
                     80:     self._setObject(id,ECHO_sqlElement(id,title,query,field,baseUrl))
                     81:     
                     82:     if RESPONSE is not None:
                     83:         RESPONSE.redirect('manage_main')
                     84: 
                     85: 
                     86: class ECHO_pageTemplate(ZopePageTemplate):
                     87:     """pageTemplate Objekt"""
                     88:     meta_type="ECHO_pageTemplate"
                     89: 
                     90:     _default_content_fn = os.path.join(package_home(globals()),
                     91:                                        'ECHO_pageTemplateDefault.html')
                     92: 
1.3       dwinter    93:     manage_options=ZopePageTemplate.manage_options+(
                     94:         {'label':'Weight','action':'changeECHO_pageTemplateWeightForm'},
                     95:         )
                     96: 
                     97:     def changeECHO_pageTemplateWeightForm(self):
1.4       dwinter    98:         """change"""
                     99:         pt=PageTemplateFile('Products/ECHO_content/ChangeECHO_pageTemplateWeight.zpt').__of__(self)
                    100:         return pt()
                    101: 
                    102:     def changeECHO_pageTemplateWeight(self,weight,RESPONSE=None):
                    103:         """change"""
                    104:         self.weight=weight
1.3       dwinter   105: 
1.4       dwinter   106:         if RESPONSE is not None:
                    107:             RESPONSE.redirect('manage_main')
                    108:         
                    109:     def getWeight(self):
                    110:         """get weight"""
                    111:         if hasattr(self,'weight'):
                    112:             return self.weight
                    113:         else:
                    114:             return 0
1.3       dwinter   115: 
                    116: 
1.1       dwinter   117: 
                    118:     ## def __init__(self, id, text=None, content_type=None):
                    119: ##         self.id = str(id)
                    120: ##         self.ZBindings_edit(self._default_bindings)
                    121: ##         if text is None:
                    122: ##             text = open(self._default_cont).read()
                    123: ##         self.pt_edit(text, content_type)
                    124: 
                    125: def manage_AddECHO_pageTemplateForm(self):
                    126:     """Form for adding"""
                    127:     pt=PageTemplateFile('Products/ECHO_content/AddECHO_pageTemplate.zpt').__of__(self)
                    128:     return pt()
                    129: 
                    130: from urllib import quote
                    131: 
                    132: 
1.3       dwinter   133: def manage_AddECHO_pageTemplate(self, id, weight= 0,title=None, text=None,
1.1       dwinter   134:                            REQUEST=None, submit=None):
                    135:     "Add a Page Template with optional file content."
                    136: 
                    137:     
                    138:     id = str(id)
                    139:     if REQUEST is None:
                    140:         self._setObject(id, ECHO_pageTemplate(id, text))
                    141:         ob = getattr(self, id)
1.3       dwinter   142:         setattr(ob,'weight',weight)
1.1       dwinter   143:         if title:
                    144:             ob.pt_setTitle(title)
                    145:         return ob
                    146:     else:
                    147:         file = REQUEST.form.get('file')
                    148:         headers = getattr(file, 'headers', None)
                    149:         if headers is None or not file.filename:
                    150:             zpt = ECHO_pageTemplate(id)
                    151:         else:
                    152:             zpt = ECHO_pageTemplate(id, file, headers.get('content_type'))
                    153: 
                    154:         self._setObject(id, zpt)
1.3       dwinter   155:         ob = getattr(self, id)
                    156:         setattr(ob,'weight',weight)
1.1       dwinter   157: 
                    158:         try:
                    159:             u = self.DestinationURL()
                    160:         except AttributeError:
                    161:             u = REQUEST['URL1']
                    162: 
                    163:         if submit == " Add and Edit ":
                    164:             u = "%s/%s" % (u, quote(id))
                    165:         REQUEST.RESPONSE.redirect(u+'/manage_main')
                    166:     return ''
                    167: 
                    168: 
                    169: class ECHO_navigation(Folder):
                    170:     """Navigations Element"""
                    171:     meta_type="ECHO_Navigation"
                    172: 
                    173:     displayedMetaTypes=['ECHO_collection','ECHO_pageTemplate','ZSQLExtendFolder','ECHO_sqlElement']
                    174:     
                    175:     def __init__(self,id,title,pathToHierarchy):
                    176:         """init"""
                    177:         self.id=id
                    178:         self.title=title
                    179:         self.pathToHierarchy=pathToHierarchy
                    180: 
                    181:     manage_options = Folder.manage_options+(
                    182:         {'label':'Main Config','action':'ECHO_navigationConfigForm'},
                    183:         )
                    184: 
                    185:     def ECHO_navigationConfigForm(self):
                    186:         """configForm"""
                    187:         pt=PageTemplateFile('Products/ECHO_content/ChangeECHO_navigation.zpt').__of__(self)
                    188:         return pt()
                    189:     
                    190:     def ECHO_navigationConfig(self,title,pathToHierarchy,RESPONSE=None):
                    191:         """config"""
                    192:         self.title=title
                    193:         self.pathToHierarchy=pathToHierarchy
                    194: 
                    195:         if RESPONSE is not None:
                    196:             RESPONSE.redirect('manage_main')
                    197: 
                    198: 
                    199:     def getColls(self,obj,depth):
                    200:         nav={}
                    201:         #print "HERE",obj.
                    202:         for keys in obj.__dict__.keys():
                    203:             x=getattr(obj,keys)
                    204:             if hasattr(x,"meta_type"):
                    205:                 if x.meta_type in self.displayedMetaTypes:
                    206:                     if depth>1:
                    207:                         nav[x.getId()]=(self.getColls(x,depth-1),x)
                    208:                     else:
                    209:                         nav[x.getId()]=(None,x)
                    210:         return nav
                    211:     
                    212:     def createNavHash(self,depth):
                    213:         """Auslesen des Hierarchiebuames"""
                    214:         temp=self.pathToHierarchy[0:]
                    215:         temp=re.sub("/",".",temp)
                    216:         temp="self.aq_parent"+temp
                    217:         
                    218:         objtemp=eval(temp)
                    219:         nav={}
                    220:         obj=objtemp
                    221:         
                    222:         #exec(obj)
                    223: 
                    224:         #objtemp = compile(temp,'<string>','single')
                    225:         #obj=eval(objtemp)
1.4       dwinter   226:         #print obj 
1.1       dwinter   227:         
                    228:         #print obj.__dict__.keys()
                    229:         
                    230:         for keys in obj.__dict__.keys():
                    231:             x=getattr(obj,keys)
                    232:             if hasattr(x,"meta_type"):
                    233:                 #print x.meta_type
                    234:                 if x.meta_type in self.displayedMetaTypes:
1.5     ! dwinter   235:                    
1.1       dwinter   236:                     if depth>1:
                    237:                         nav[x.getId()]=(self.getColls(x,int(depth)-1),x)
                    238:                     else:
                    239:                         nav[x.getId()]=(None,x)
                    240:                     
                    241: 
                    242:         #print nav
                    243:         return nav
                    244: 
1.5     ! dwinter   245:     def barFromHash(self,hash,start=None,sortField=None):
1.1       dwinter   246:         """Erzeuge Navigations Element"""
                    247:         #print "hash",hash
                    248:         listNav=[]
                    249:         if not start:
                    250:             temp=hash
1.5     ! dwinter   251:             sortField="weight"
1.1       dwinter   252:         else: # list mit pfad zum hash
                    253:             temp=hash
1.5     ! dwinter   254:             print "HI",sortField
        !           255:             if not sortField:
        !           256:                 tempObj=self.pathToHierarchy[0:]
        !           257:                 tempObj=re.sub("/",".",tempObj)
        !           258:                 tempObj="self.aq_parent"+tempObj
        !           259: 
        !           260:                 objtemp=eval(tempObj)
        !           261: 
        !           262:                 obj=objtemp
        !           263: 
        !           264:                 for x in start:
        !           265: 
        !           266: 
        !           267:                     obj=getattr(obj,x)
        !           268: 
        !           269:                 if hasattr(obj,'sortfield'):
        !           270:                     sortField=obj.sortfield
        !           271:                 else:
        !           272:                     sortField='weight'
1.1       dwinter   273:             for x in start:
1.5     ! dwinter   274:                     temp=temp[x][0]
        !           275:         print "HELL",sortField
        !           276:         for x in self.tempSorted(temp, field=sortField):
1.4       dwinter   277:             if not temp[x][1].title == "":
                    278:                 if temp[x][1].meta_type=="ECHO_sqlElement":
                    279:                     for z in temp[x][1].getNavList():
                    280:                         listNav.append((z[0],z[1]))
                    281:                 else:
                    282:                     listNav.append((temp[x][1].title,createPath(self.absolute_url(),temp[x][1].absolute_url())))
                    283:                     
1.5     ! dwinter   284:         print self.getId(),start
        !           285:         print listNav
1.1       dwinter   286: 
                    287:         #html=""
                    288:         #for k in listNav:
                    289:         #    print k
                    290:         #    html=html+"<a href='%s'>%s</a>   "% (self.absolute_url()+createPath(k[1][1].absolute_url()),k[0])
                    291: 
                    292:         return listNav
                    293: 
1.5     ! dwinter   294:     def tempSorted(self,hash,field="weight"):
1.4       dwinter   295:         ls=[]
1.5     ! dwinter   296:         print "SORT",field
1.4       dwinter   297:         for x in hash.keys():
                    298:             #print hash[x][1]
1.5     ! dwinter   299:             if hasattr(hash[x][1],field):
        !           300:                 weight=getattr(hash[x][1],field)
1.4       dwinter   301:                 #print weight
                    302:             else:
                    303:                 weight=0
                    304: 
                    305:             ls.append((x,weight))
                    306: 
                    307:         ls.sort(sortWeight)
                    308:         
                    309:         return [x[0] for x in ls]
                    310: 
                    311:     
                    312:         
                    313:             
1.1       dwinter   314:     def isSelectedPath(self,item):
                    315:         """test is path is already selected"""
                    316:         found=re.search("\?(.*)",item[1])
                    317:         if found:
                    318:             temp=re.sub(" ","%20",found.group(0))
                    319:             #print temp+"::"+self.REQUEST['QUERY_STRING']
                    320:             if ("?"+self.REQUEST['QUERY_STRING'])==temp:
                    321:                 return 1
                    322: 
                    323:         if re.search(item[1],self.REQUEST['URL']):
                    324:             return 1
                    325:         else:
                    326:             return 0
                    327:         
                    328:     
                    329:     def buttonsFromHash(self,hash,start=None,orientation="horizontal"):
                    330:         
                    331:         """Generate Buttons"""
                    332:         if orientation=="horizontal":
                    333:             html="<table><tr>"
                    334:             startTag="<td>"
                    335:             endTag="</td>"
                    336:             endHtml="</tr></table>"
                    337: 
                    338:         else:
                    339:             html="<table>"
                    340:             startTag="<tr><td>"
                    341:             endTag="</td></tr>"
                    342:             endHtml="</table>"
                    343:             
                    344:         if not start:
                    345:             temp=hash
                    346:         else:
                    347:             temp=hash
                    348:             for x in start:
                    349:                 temp=temp[x][0]
                    350:                 #print temp
                    351:         
1.5     ! dwinter   352:         for key in self.tempSorted(temp):
1.1       dwinter   353:             
                    354:             description=temp[x][1].title
1.2       dwinter   355:          
1.3       dwinter   356:             url=createPath(self.absolute_url(),temp[key][1].absolute_url())
1.2       dwinter   357: 
1.1       dwinter   358:             if (self.REQUEST['URL']==url) | (self.REQUEST['URL']==url+"/index_html"):
                    359:                 html=html+startTag+"[%s]" % description+endTag
                    360:             else:                
                    361:                 html=html+startTag+"[<a href='%s'>%s</a>]" % (url,description)+endTag
                    362:             
                    363: 
                    364:         html=html+endHtml
                    365:         
                    366:         return html
                    367: 
                    368:     def mainNavBar(self):
                    369:         """print main navigation bar"""
                    370:         keys=""
1.5     ! dwinter   371:         print "NAVBAR",self.getId()
1.1       dwinter   372:         try:
                    373:             keys=self.buttonsFromHash(self.createNavHash(0))
                    374:         except:
                    375:             keys=""
                    376:             
                    377:         return keys
                    378: 
                    379:     def mainNavElements(self):
                    380:         """print main navigation bar"""
                    381:         keys=""
1.5     ! dwinter   382:         print "NAVELEMENT",self.getId()
        !           383:         #try:
        !           384:       
        !           385:         keys=self.barFromHash(self.createNavHash(0))
1.1       dwinter   386: 
1.5     ! dwinter   387:         #except:
        !           388:         #    keys=""
1.1       dwinter   389:             
                    390:         return keys
                    391:     
                    392:     def secondNavElements(self):
                    393:         """Zweite Ordnung"""
                    394:         
                    395:         hash=self.createNavHash(2)
                    396:         actual_url=self.REQUEST['URL']
                    397:         
                    398:         ult_temp=re.sub(self.absolute_url(),"",actual_url)
                    399:         #print ult_temp
                    400: 
                    401:         splitted=ult_temp.split("/")
                    402:         
                    403: 
                    404:         ## if splitted[len(splitted)-1]=="index_html":
                    405: ##             start=[splitted[len(splitted)-2]]
                    406: ##         else:
                    407: ##             start=[splitted[len(splitted)-1]]
                    408: 
                    409:         start=[splitted[2]]
                    410:         #print start
1.5     ! dwinter   411:        
1.1       dwinter   412:         keys=self.barFromHash(hash,start=start)
                    413:         
                    414:         
                    415:         return keys
                    416: 
                    417: 
                    418:     def secondNavBar(self):
                    419:         """Zweite Ordnung"""
                    420: 
                    421:         hash=self.createNavHash(2)
                    422:         actual_url=self.REQUEST['URL']
                    423:         
                    424:         ult_temp=re.sub(self.absolute_url(),"",actual_url)
                    425:         #print ult_temp
                    426: 
                    427:         splitted=ult_temp.split("/")
                    428:         
                    429: 
                    430:         ## if splitted[len(splitted)-1]=="index_html":
                    431: ##             start=[splitted[len(splitted)-2]]
                    432: ##         else:
                    433: ##             start=[splitted[len(splitted)-1]]
                    434: 
                    435:         start=[splitted[2]]
                    436:         #print start
                    437:         
                    438:         keys=self.buttonsFromHash(hash,start=start,orientation="vertical")
                    439:         
                    440:         
                    441:         return keys
                    442: 
                    443: def manage_AddECHO_navigationForm(self):
                    444:     """Form for adding"""
                    445:     pt=PageTemplateFile('Products/ECHO_content/AddECHO_navigation.zpt').__of__(self)
                    446:     return pt()
                    447: 
                    448: def manage_AddECHO_navigation(self,id,title,pathToHierarchy,RESPONSE=None):
                    449:     """Add an ECHO_root"""
                    450:     self._setObject(id,ECHO_navigation(id,title,pathToHierarchy))
                    451:     
                    452:     if RESPONSE is not None:
                    453:         RESPONSE.redirect('manage_main')
                    454: 
                    455: 
                    456: #helpers
                    457: 
1.3       dwinter   458: 
                    459: 
                    460: def createPath(url1,url2):
                    461:     temp1=url1.split("/")
                    462:     temp2=url2.split("/")
                    463:     for test in temp1:
                    464:         if temp2[0]==test:
                    465:             del temp2[0]
                    466: 
                    467:     return url1+"/"+string.join(temp2,"/")
1.4       dwinter   468: 
                    469: def sortWeight(x,y):
                    470:     #print x[1],y[1]
                    471:     return cmp(x[1],y[1])
1.1       dwinter   472:     

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