Return to ECHO_Nav.py CVS log

Up to [Repository] / ECHO_content

echo navigation

# Objekte zur Erzeugung von Navigationselementen


from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
import re
import string
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
import os.path
from Globals import package_home
import urllib

class ECHO_sqlElement(SimpleItem):
    """Erzeuge navigation aus sql-abfrage"""
    meta_type="ECHO_sqlElement"
    baseUrl=""
    
    def __init__(self,id,title,query,field,baseUrl):
        """init"""
        self.id=id
        self.title=title
        self.query=query
        self.field=field
        self.baseUrl=baseUrl

    manage_options= SimpleItem.manage_options+(
        {'label':'Main Config','action':'changeECHO_sqlElementForm'},
        )

    def changeECHO_sqlElementForm(self):
        """change"""
        pt=PageTemplateFile('Products/ECHO_content/ChangeECHO_sqlElement.zpt').__of__(self)
        return pt()

    def changeECHO_sqlElement(self,title,query,field,baseUrl,RESPONSE=None):
        """change"""
        self.title=title
        self.query=query
        self.field=field
        self.baseUrl=baseUrl

        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def searchQuery(self):
        return self.search(var=self.query)
    
    def getNavList(self):
        """ausgabe der treffer list für navigation"""
        records=self.searchQuery()
        if not records:
            return []
        else:
            ret=[]
            for record in records:
                ret.append((getattr(record,self.field),self.baseUrl+str(getattr(record,self.field))))
            return ret
    

def manage_AddECHO_sqlElementForm(self):
    """Form for adding"""
    pt=PageTemplateFile('Products/ECHO_content/AddECHO_sqlElement.zpt').__of__(self)
    return pt()

def manage_AddECHO_sqlElement(self,id,title,query,field,baseUrl,RESPONSE=None):
    """Add an ECHO_sqlelement"""
    self._setObject(id,ECHO_sqlElement(id,title,query,field,baseUrl))
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')


class ECHO_pageTemplate(ZopePageTemplate):
    """pageTemplate Objekt"""
    meta_type="ECHO_pageTemplate"

    _default_content_fn = os.path.join(package_home(globals()),
                                       'ECHO_pageTemplateDefault.html')


    ## def __init__(self, id, text=None, content_type=None):
##         self.id = str(id)
##         self.ZBindings_edit(self._default_bindings)
##         if text is None:
##             text = open(self._default_cont).read()
##         self.pt_edit(text, content_type)

def manage_AddECHO_pageTemplateForm(self):
    """Form for adding"""
    pt=PageTemplateFile('Products/ECHO_content/AddECHO_pageTemplate.zpt').__of__(self)
    return pt()

from urllib import quote


def manage_AddECHO_pageTemplate(self, id, title=None, text=None,
                           REQUEST=None, submit=None):
    "Add a Page Template with optional file content."

    
    id = str(id)
    if REQUEST is None:
        self._setObject(id, ECHO_pageTemplate(id, text))
        ob = getattr(self, id)
        if title:
            ob.pt_setTitle(title)
        return ob
    else:
        file = REQUEST.form.get('file')
        headers = getattr(file, 'headers', None)
        if headers is None or not file.filename:
            zpt = ECHO_pageTemplate(id)
        else:
            zpt = ECHO_pageTemplate(id, file, headers.get('content_type'))

        self._setObject(id, zpt)

        try:
            u = self.DestinationURL()
        except AttributeError:
            u = REQUEST['URL1']

        if submit == " Add and Edit ":
            u = "%s/%s" % (u, quote(id))
        REQUEST.RESPONSE.redirect(u+'/manage_main')
    return ''


class ECHO_navigation(Folder):
    """Navigations Element"""
    meta_type="ECHO_Navigation"

    displayedMetaTypes=['ECHO_collection','ECHO_pageTemplate','ZSQLExtendFolder','ECHO_sqlElement']
    
    def __init__(self,id,title,pathToHierarchy):
        """init"""
        self.id=id
        self.title=title
        self.pathToHierarchy=pathToHierarchy

    manage_options = Folder.manage_options+(
        {'label':'Main Config','action':'ECHO_navigationConfigForm'},
        )

    def ECHO_navigationConfigForm(self):
        """configForm"""
        pt=PageTemplateFile('Products/ECHO_content/ChangeECHO_navigation.zpt').__of__(self)
        return pt()
    
    def ECHO_navigationConfig(self,title,pathToHierarchy,RESPONSE=None):
        """config"""
        self.title=title
        self.pathToHierarchy=pathToHierarchy

        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')


    def getColls(self,obj,depth):
        nav={}
        #print "HERE",obj.
        for keys in obj.__dict__.keys():
            x=getattr(obj,keys)
            if hasattr(x,"meta_type"):
                if x.meta_type in self.displayedMetaTypes:
                    if depth>1:
                        nav[x.getId()]=(self.getColls(x,depth-1),x)
                    else:
                        nav[x.getId()]=(None,x)
        return nav
    
    def createNavHash(self,depth):
        """Auslesen des Hierarchiebuames"""
        temp=self.pathToHierarchy[0:]
        temp=re.sub("/",".",temp)
        temp="self.aq_parent"+temp
        
        objtemp=eval(temp)
        nav={}
        obj=objtemp
        
        #exec(obj)

        #objtemp = compile(temp,'<string>','single')
        #obj=eval(objtemp)
        print obj 
        
        #print obj.__dict__.keys()
        
        for keys in obj.__dict__.keys():
            x=getattr(obj,keys)
            if hasattr(x,"meta_type"):
                #print x.meta_type
                if x.meta_type in self.displayedMetaTypes:
                    if depth>1:
                        nav[x.getId()]=(self.getColls(x,int(depth)-1),x)
                    else:
                        nav[x.getId()]=(None,x)
                    

        #print nav
        return nav

    def barFromHash(self,hash,start=None):
        """Erzeuge Navigations Element"""
        #print "hash",hash
        listNav=[]
        if not start:
            temp=hash
        else: # list mit pfad zum hash
            temp=hash
            for x in start:
                temp=temp[x][0]

        for x in temp.keys():
            if temp[x][1].meta_type=="ECHO_sqlElement":
                for z in temp[x][1].getNavList():
                    listNav.append((z[0],z[1]))
            else:
                listNav.append((temp[x][1].title,self.absolute_url()+createPath(temp[x][1].absolute_url())))

        #print listNav

        #html=""
        #for k in listNav:
        #    print k
        #    html=html+"<a href='%s'>%s</a>   "% (self.absolute_url()+createPath(k[1][1].absolute_url()),k[0])

        return listNav

    def isSelectedPath(self,item):
        """test is path is already selected"""
        found=re.search("\?(.*)",item[1])
        if found:
            temp=re.sub(" ","%20",found.group(0))
            #print temp+"::"+self.REQUEST['QUERY_STRING']
            if ("?"+self.REQUEST['QUERY_STRING'])==temp:
                return 1

        if re.search(item[1],self.REQUEST['URL']):
            return 1
        else:
            return 0
        
    
    def buttonsFromHash(self,hash,start=None,orientation="horizontal"):
        
        """Generate Buttons"""
        if orientation=="horizontal":
            html="<table><tr>"
            startTag="<td>"
            endTag="</td>"
            endHtml="</tr></table>"

        else:
            html="<table>"
            startTag="<tr><td>"
            endTag="</td></tr>"
            endHtml="</table>"
            
        if not start:
            temp=hash
        else:
            temp=hash
            for x in start:
                temp=temp[x][0]
                #print temp
        
        for key in temp.keys():
            
            description=temp[x][1].title
            url=self.absolute_url()+createPath(temp[key][1].absolute_url())
            
            if (self.REQUEST['URL']==url) | (self.REQUEST['URL']==url+"/index_html"):
                html=html+startTag+"[%s]" % description+endTag
            else:                
                html=html+startTag+"[<a href='%s'>%s</a>]" % (url,description)+endTag
            

        html=html+endHtml
        
        return html

    def mainNavBar(self):
        """print main navigation bar"""
        keys=""
        try:
            keys=self.buttonsFromHash(self.createNavHash(0))
        except:
            keys=""
            
        return keys

    def mainNavElements(self):
        """print main navigation bar"""
        keys=""

        try:
            keys=self.barFromHash(self.createNavHash(0))
        except:
            keys=""
            
        return keys
    
    def secondNavElements(self):
        """Zweite Ordnung"""
        
        hash=self.createNavHash(2)
        actual_url=self.REQUEST['URL']
        
        ult_temp=re.sub(self.absolute_url(),"",actual_url)
        #print ult_temp

        splitted=ult_temp.split("/")
        

        ## if splitted[len(splitted)-1]=="index_html":
##             start=[splitted[len(splitted)-2]]
##         else:
##             start=[splitted[len(splitted)-1]]

        start=[splitted[2]]
        #print start
        
        keys=self.barFromHash(hash,start=start)
        
        
        return keys


    def secondNavBar(self):
        """Zweite Ordnung"""

        hash=self.createNavHash(2)
        actual_url=self.REQUEST['URL']
        
        ult_temp=re.sub(self.absolute_url(),"",actual_url)
        #print ult_temp

        splitted=ult_temp.split("/")
        

        ## if splitted[len(splitted)-1]=="index_html":
##             start=[splitted[len(splitted)-2]]
##         else:
##             start=[splitted[len(splitted)-1]]

        start=[splitted[2]]
        #print start
        
        keys=self.buttonsFromHash(hash,start=start,orientation="vertical")
        
        
        return keys

def manage_AddECHO_navigationForm(self):
    """Form for adding"""
    pt=PageTemplateFile('Products/ECHO_content/AddECHO_navigation.zpt').__of__(self)
    return pt()

def manage_AddECHO_navigation(self,id,title,pathToHierarchy,RESPONSE=None):
    """Add an ECHO_root"""
    self._setObject(id,ECHO_navigation(id,title,pathToHierarchy))
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')


#helpers

def createPath(url):
    temp=url.split("/")
    del temp[0]
    del temp[1]
    return string.join(temp,"/")