Return to ZSQLExtend.py CVS log

Up to [Repository] / ZSQLExtend

first version of searchRel

from OFS.Folder import Folder
from Globals import Persistent
from Acquisition import Implicit
from Globals import DTMLFile
import urllib
import re
import string
from pyPgSQL import libpq
from AccessControl import getSecurityManager
import os.path
from Products.PageTemplates.PageTemplateFile import PageTemplateFile

from Products.ZSQLMethods.SQL import SQLConnectionIDs
import Shared.DC.ZRDB.DA

def showSQLConnectionIDs(self):
    return SQLConnectionIDs(self)

class ZSQLExtendFolder(Folder,Persistent, Implicit):
    """Folder"""
    meta_type="ZSQLExtendFolder"

    def testneu(self):
        """test"""
        relStatement="""period like '%s%%'"""
        statement="select * from cdli_cat"
        wherePart="museum_no like 'VAT%'"
        classes=['Uruk III','Uruk IV']
        return self.searchRel(relStatement,statement,wherePart,classes)
    
    def searchRel(self,relStatement,statement,wherePart,classes):
        """suche relative haufigkeiten"""
        ret={}
        allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))
        print statement + " where "+wherePart
        for oneclass in classes:
            ret[oneclass]=len(self.ZSQLSimpleSearch(statement + " where ("+wherePart+") and "+ relStatement%oneclass))
            print statement + " where ("+wherePart+") and "+ relStatement%oneclass
        return (ret,allRecords)
                  
    def content_html(self):
        """template fuer content"""
        
        try:
            obj=getattr(self,"ZSQLBibliography_template")
            return obj()
        except:
            pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt',content_type='text/htm').__of__(self)
            pt.content_type="text/html"
            
            return pt()

        
    def getWeight(self):
        """getLabe"""
        try:
            return self.weight
        except:
            return ""

    def getLabel(self):
        """getLabe"""
        try:
            return self.label
        except:
            return ""

    def getDescription(self):
        """getLabe"""
        try:
            return self.description
        except:
            return ""

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

    def changeZSQLExtendForm(self):
        """change folder config"""
        pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLExtendForm.zpt').__of__(self)
        return pt()


    def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):
        """change it"""
        self.connection_id=connection_id
        self.weight=weight
        self.label=label
        self.description=description
        
        if REQUEST is not None:
            return self.manage_main(self, REQUEST)

    def formatAscii(self,str,url=None):
        """ersetze ascii umbrueche durch <br>"""
        #url=None
        if url and str:
            
            retStr=""
            words=str.split("\n")
            
            for word in words:
                strUrl=url%word
                #print "str",strUrl
                retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
            str=retStr
        if str:
            return re.sub(r"[\n]","<br/>",str)
        else:
            return ""
        
    def getSAttribute(self,obj,atribute,pref=''):
        """get Attribute or emptystring"""
        
        #print "obj",obj
        try:
            return pref+getattr(obj,atribute)
        except:
            return ""
        
    def getS(self,str):
        """make none to empty string"""
        if str:
            return str
        else:
            return ""

    def actualPath(self,url=None):
	"""path"""

        if self.REQUEST['HTTP_X_FORWARDED_SERVER']=='':
            host=self.REQUEST['HTTP_HOST']
        else:
            host=self.REQUEST['HTTP_X_FORWARDED_SERVER']
	if not url:
		return "http://"+host+self.REQUEST['PATH_TRANSLATED']
    	else:
		temp=self.REQUEST[url].split("/")
		temp[2]=host
		return string.join(temp,"/")

    def getRequest(self):
	"""request"""
	return self.REQUEST

    def lowerEnd(self,path):
        """oinly for demo"""
        return os.path.splitext(path)[0]+".jpg"
        
    def ZSQLisEmpty(self,field):
        """Teste ob Treffer leer"""
        #print "field",field
        if not field:
            return 1
        if field=="":
            return 1
        return 0

    def ZSQLsearchOptions(self,fieldname=""):
        """return HTML Fragment with search options"""
	
        ret="""<select name="-op_%s">
	<option value="bw">begins with</option>          	<!-- begins with / beginnt mit, "Wort*" -->
	<option value="ew">ends with</option>
   	<option value="ct" selected>contains</option>          		<!-- contains / enthaellt, "Wort" -->
    <option value="eq">equals</option>          		<!-- equals / ist, =Wort -->
</select>"""%fieldname
        return ret

    def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
        """generate select oprions form a cr seperated list"""
        fields=listField.split("\n")
        ret=""
        for field in fields:
            if checked and (field in checked.split("\n")):
                ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
            else:
                ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
        return ret


    def ZSQLOptionsFromCRList(self,fieldname,listField, multiple=''):
        """generate select oprions form a cr seperated list"""
        fields=listField.split("\n")
        ret="""<select name="%s" %s>
            """%(fieldname,multiple)
        for field in fields:
            ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
        ret+="""</select>"""
        return ret

    def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None):
        """generate select oprions form a search list seperated list"""
        if not valueName:
            valueName=fieldName
            
        ret="""<select name="%s" %s>
            """%(fieldname,multiple)
        if start:
	    if start==' ':
		start=''
                if not startValue:
                    startValue=start
                    
            ret+="""<option value="%s">%s</option>"""%(startValue,start)
        for result in results:
            field=getattr(result,fieldName)
            fieldValue=getattr(result,valueName)
            ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
        ret+="""</select>"""
        return ret

            
    def ZSQLInlineSearchU(self,storename=None,**argv):
        """one element if exists"""
        qs=[]
        if storename:
            """store"""
        else:
            storename="foundCount"
            
    

        #print "INLINE:",argv
        for a in argv.keys():
            qs.append(a+"="+urllib.quote(str(argv[a])))
        #return []  
        ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)

        try:
            return ret[0]
        except:
            return None
        
    def ZSQLInlineSearch(self,storename=None,**argv):
        """inlinesearch"""
        qs=[]
        if storename:
            """store"""
        else:
            storename="foundCount"
            
    

        #print "INLINE:",argv
        for a in argv.keys():
            qs.append(a+"="+urllib.quote(str(argv[a])))
        #return []  
        return self.parseQueryString(string.join(qs,","),"_",storename=storename)

    def ZSQLInlineSearch2(self,query):
        """inlinesearch"""
        qs=[]
        
    

        #print "INLINE:",query
        return self.ZSQLSimpleSearch(query)
        

    def ZSQLSimpleSearch(self,query=None):
        """ returrn SQLSearch"""
        if not query:
            query=self.query
           
        if self.search.meta_type=="Z SQL Method":
            return self.search(var=query)
        else:
            if self.aq_parent.aq_parent.search.meta_type=="Z SQL Method":
                return self.aq_parent.aq_parent.search(var=query)
            else:
                return []
    
        
        
    def ZSQLAdd(self):
        """Neuer Eintrag"""
        qs=self.REQUEST['QUERY_STRING']
        addList={}
        for q in qs.split("&"):
            name=re.sub("r'+'"," ",q.split("=")[0].lower())
            value=q.split("=")[1]
	    value=re.sub(r'\+'," ",value)
	    value=urllib.unquote(value)	
            if name=="-table":
                table=urllib.unquote(value)
            elif name=="-format":
                format=urllib.unquote(value)
            elif (not name[0]=="-") and (not len(value)==0):
                addList[urllib.unquote(name)]=urllib.unquote(value)

        keyList=[]
        valueList=[]
        for x in addList.keys():
            keyList.append("\""+x+"\"")
            valueList.append(libpq.PgQuoteString(addList[x]))

        keyString=string.join(keyList,",")
        valueString=string.join(valueList,",")
        
        queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)
        self.ZSQLSimpleSearch(queryString)
        return self.REQUEST.RESPONSE.redirect(format)
        
    def ZSQLChange(self,**argv):
        """Ändern von Einträgen"""
        #qs=self.REQUEST['QUERY_STRING']
        # very bad hack
        qs_temp=[]
    
        for a in self.REQUEST.form.keys():
            qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))

        qs=string.join(qs_temp,"&")

    
        #print "CHANGE QS",self.REQUEST
        #return self.REQUEST
        changeList=[]
        for q in qs.split("&"):
            name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
            value=q.split("=")[1]
            value=re.sub(r'\+'," ",value)
	    value=urllib.unquote(value)
	    if name=="-table":
                table=urllib.unquote(value)
            elif name=="-identify":
                identify=urllib.unquote(value)
                identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])
            elif name=="-format":
                format=urllib.unquote(value)
            elif (not name[0]=="-") and (not len(value)==0):
                changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))
        changeString=string.join(changeList,",")
        queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
        self.ZSQLSimpleSearch(queryString)
        return self.REQUEST.RESPONSE.redirect(format)

    def ZSQLChange_old(self):
        """Ändern von Einträgen"""
        qs=self.REQUEST['QUERY_STRING']
        #print "CHANGE QS",self.REQUEST
        #return self.REQUEST
        changeList=[]
        for q in qs.split("&"):
            name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
            value=q.split("=")[1]
            value=re.sub(r'\+'," ",value)
	    value=urllib.unquote(value)
	    if name=="-table":
                table=urllib.unquote(value)
            elif name=="-identify":
                identify=urllib.unquote(value)
                identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])
            elif name=="-format":
                format=urllib.unquote(value)
            elif (not name[0]=="-") and (not len(value)==0):
                changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))
        changeString=string.join(changeList,",")
        queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
        self.ZSQLSimpleSearch(queryString)
        return self.REQUEST.RESPONSE.redirect(format)



    def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],**argv):
        """find2"""
        #search1= self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt='cdli_translit',restrictField='id_text',NoQuery='yes',NoLimit='yes',**argv)

        
        #search2 = self.ZSQLFind(tableExt='cdli_cat',qs="",select="oid,*",storename=None,restrictConnect=('cdli_cat.id_text',search1),**argv)

        search1= self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt='cdli_cat',restrictField='id_text',NoQuery='yes',NoLimit='yes',**argv)

        search2 = self.ZSQLFind(tableExt='cdli_translit',qs="",select="oid,*",storename=None,restrictConnect=('cdli_translit.id_text',search1),**argv)
        return search2
    
        #return self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,**argv)
    
    def ZSQLFind(self,qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,**argv):
        """Find"""

        def delEmpty(list):
            ret=[]
            for x in list:
                splitted=x.split("=")
                if (len(splitted)>1) and not (splitted[1]==' '):
                    ret.append(x)
            return ret
        
        #self.REQUEST.SESSION['come_from_search']="no" # zurücksetzen
        if qs=="":
           
           if self.REQUEST['QUERY_STRING']:
               qs=self.REQUEST['QUERY_STRING']

               
               qs=string.join(qs.split("&"),",")
               
               for field in argv.keys():
                   
                   qs+=",-%s=%s"%(field,argv[field])
                   
           else:
               
               qs=self.REQUEST.SESSION.get('query','')
               
               for field in argv.keys():
                   #print field
                   qs+=",-%s=%s"%(field,argv[field])
               
        else:
            self.REQUEST['QUERY_STRING']=qs

            qs=string.join(qs.split("&"),",")
            
        
        
        qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.

        qs=string.join(delEmpty(qs.split(",")),",")

        if storename:
            """store"""
        else:
            storename="foundCount"


        #print "calling Query with",repr(NoQuery)
        ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename,tableExt=tableExt,NoQuery=NoQuery,NoLimit=NoLimit,restrictField=restrictField,restrictConnect=restrictConnect,filter=filter)
        #print self.REQUEST.SESSION["foundCount"]
        

        return ret

    def ZSQLFoundCountLen(self,var):
        return len(var)
            
    def ZSQLFoundCount(self,qs="",select="*",storename=None):
        
       ##  if qs=="":
            
##             if self.REQUEST['QUERY_STRING']:
            
##                 qs=self.REQUEST['QUERY_STRING']
##                 qs=string.join(qs.split("&"),",")
##             else:
            
##                 qs=self.REQUEST.SESSION['query']
##         else:
##             qs=string.join(qs.split("&"),",")


##         temp= self.parseQueryString(qs,"-",select=select,storemax="yes",nostore="yes")
        if storename:
            """store"""
        else:
            storename="foundCount"
        
        return self.REQUEST.SESSION[storename]['count']

    def ZSQLRangeStart(self,storename=None):
        
        if storename:
            """store"""
        else:
            storename="foundCount"
        
        return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
    
    def ZSQLRangeSize(self,storename=None):
        
        if storename:
            """store"""
        else:
            storename="foundCount"
            
        return self.REQUEST.SESSION[storename]['rangeSize']

    def ZSQLRangeEnd(self,storename=None):
        
        if storename:
            """store"""
        else:
            storename="foundCount"
        
        return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))
    
    def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None):
        """analysieren den QueryString"""
        #print "NO",nostore
        lop="AND" # standardsuche mit and
        max="ALL" #standard alle auswählen
        maxstr=""
        whereList=[]
        sort=""
        op="bw"
        opfields={}
        lopfields={} #Verknüpfung bei mehrfachauswahl von einem feld
        skip=""
        rangeStart=0
        limit=0
        searchFields={}
        searchFieldsOnly={}
        if not select:
            select="oid,*"
        #print "Q",nostore,qs
        #check for op 
        
	splitted=qs.split(",")
        if tableExt:
            table=tableExt

        if restrictField:
                    select=restrictField
            
        for q in splitted:
                
                name=re.sub("r'+'"," ",q.split("=")[0].lower())
                try:
                    value=urllib.unquote(q.split("=",1)[1])
                except:
                    value=""
                #print "Hi",name[0:3],q
                if name[0:3]==iCT+"op":
                    op=value

                    field=name[4:]
                    opfields[field]=op

                if name[0:4]==iCT+"lop":
                    lop=value

                    field=name[5:]
                    lopfields[field]=lop
                    #print "HI",op,field
	#print opfieldsa
        #now analyse the querystring
        for q in qs.split(","):
            
            
            #try:

            name=re.sub("r'+'"," ",q.split("=")[0].lower())
            try:
                value=urllib.unquote(q.split("=",1)[1])
            except:
                value=""
                
            #value=libpq.PgQuoteString(value)
            
            
            if name==iCT+"lop":
                lop=value
            elif name==iCT+"table":
                if not tableExt: 
                    table=value
            elif name==iCT+"select":
                if not restrictField:
                    select=value
            elif name==iCT+"max":
                if not NoLimit:
                    maxstr="LIMIT "+str(value)
                    limit=str(value)
            elif name==iCT+"skip":
                skip="OFFSET "+str(value)
                rangeStart=str(value)
            elif name==iCT+"join":
                whereList.append(value)
            elif name==iCT+"sort":
                sort="ORDER BY "+value.replace(' AND ',',')
            elif name==iCT+"token":
                if not nostore=="yes":
                    self.REQUEST.SESSION['token']=value

            elif name==iCT+"op":
                op=value



            elif (not name[0]==iCT) and (not len(value)==0):
                
		#print "OP",op,name
                value=value.lower()
                tmp=""
                if opfields.has_key(name):
                    op=opfields[name]
                else:
                    op="ct"
                namealt=name
                name="LOWER("+name+")"    
                if op=="ct":
                    tmp=(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))
                elif op=="gt":
                    tmp=(name+">"+libpq.PgQuoteString(value))
                elif op=="lt":
                    tmp=(name+"<"+libpq.PgQuoteString(value))
                elif op=="eq":
                    tmp=(name+"="+libpq.PgQuoteString(value))
                elif op=="bw":
                    tmp=(name+" LIKE "+libpq.PgQuoteString(value+"%"))
                elif op=="ew":
                    tmp=(name+" LIKE "+libpq.PgQuoteString("%"+value))
                op="ct"

                if (not tableExt) or (namealt.split('.')[0]==tableExt):
                    if searchFields.has_key(name):
                        searchFields[name]+=lopfields.get(name,'OR')+" "+tmp
                        searchFieldsOnly[name]+=lopfields.get(name,'OR')+" "+value
                    else: 
                        searchFields[name]=tmp
                        searchFieldsOnly[name]=value

            
       ##  for name in searchFields.keys():
##             value=searchFields[name]
                
##             if opfields.has_key(name):
##                 op=opfields[name]
##             else:
##                 op="ct"
##             name="LOWER("+name+")"    
##             if op=="ct":
##                 whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))
##             elif op=="gt":
##                 whereList.append(name+">"+libpq.PgQuoteString(value))
##             elif op=="lt":
##                 whereList.append(name+"<"+libpq.PgQuoteString(value))
##             elif op=="eq":
##                 whereList.append(name+"="+libpq.PgQuoteString(value))
##             elif op=="bw":
##                 whereList.append(name+" LIKE "+libpq.PgQuoteString(value+"%"))
##             elif op=="ew":
##                 whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value))
##             op="ct"
            
##             #except:
##             #    print "END",value,name,Exception      

        whereList=["("+searchFields[x]+")" for x in searchFields.keys()]

        if len(whereList)>0:
            if filter:
                whereStr="("+string.join(whereList," "+lop+" ")+") AND "+filter
            else:
                whereStr=string.join(whereList," "+lop+" ")
            where="WHERE "+whereStr
        else:
            if filter:
                where="WHERE "+filter
            else:
                where=""

        if restrictConnect:
            
            if len(where)==0:
                where="WHERE "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
            else:
                where+="and "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
                
        #print "QE",table
        
        query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)
        
        if not nostore=="yes":
            
            self.REQUEST.SESSION['qs']=opfields
        #print "IAMHERE again:", query

        if storename and (not NoQuery):
            query2="SELECT count(*) FROM %s %s"%(table,where)

            #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
            if not self.REQUEST.SESSION.has_key(storename):
                self.REQUEST.SESSION[storename]={}
            if self.REQUEST.SESSION[storename].has_key('queryString2'):

                if not self.REQUEST.SESSION[storename]['queryString2']==query2:
                    #print "HOOOOO",storename
                    self.REQUEST.SESSION[storename]['queryString2']=query2
                    self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count

                    #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']
                
            else:

                self.REQUEST.SESSION[storename]['queryString2']=query2
                self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
                #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
            
            
            self.REQUEST.SESSION[storename]['rangeStart']=rangeStart
            if limit=="all":
                self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
            else:
                self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
            self.REQUEST.SESSION[storename]['rangeSize']=limit
            self.REQUEST.SESSION[storename]['searchFields']=searchFields
            self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly
            
        if not NoQuery:

            return self.ZSQLQuery(query)
        else:

            return query
            
    def ZSQLQuery(self,query):
        """query"""
        return self.ZSQLSimpleSearch(query)
    
    def ZSQLSearch(self):
        """To be done"""
        rq=self.REQUEST['QUERY_STRING']
        querys=rq.split("&")
        

        for querytemp in querys:
            query=querytemp.split("=")
            try:
                if query[0].lower()=="-format":
                    formatfile=query[1]
            except:
                """nothing"""
        #print formatfile
        
        self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
        self.REQUEST.SESSION['come_from_search']="yes"
        
        return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))

    
    def ZSQLint(self,string):
        try:

            return(int(string))
        except:
            return 0

    def getZSQLSearchFieldsList(self,storename="foundCount"):
        """get searchfieldList"""
        #print self.REQUEST.SESSION[storename]['searchFields'].keys()
        return  self.REQUEST.SESSION[storename]['searchFieldsOnly'].keys()

    def getZSQLSearchFields(self,field,storename="foundCount"):
        """get searchfield"""
        #print "SF",self.REQUEST.SESSION[storename]['searchFields']
        
        return  self.REQUEST.SESSION[storename]['searchFieldsOnly'][field]

                                                
    def nextLink(self,html,storename="foundCount"):
        """nextLink"""
        try:
            limit=self.REQUEST.SESSION[storename]['rangeSize']
            if int(limit)==0 :
                limit="1"
            newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)
        except:
            limit=1
            newRangeStart=0
            
        if newRangeStart>=self.REQUEST.SESSION[storename]['count']:
            #newRangeStart=self.REQUEST.SESSION[storename]['count']-1
            return ""
        
        #create new query string
        
        if self.REQUEST['QUERY_STRING']=="":
            qs=self.REQUEST.SESSION['query']
            
            queries=string.split(qs,",")
            
            
        else:
            qs=self.REQUEST['QUERY_STRING']
            queries=string.split(qs,"&")
            
            
            
        newquery=[]

        skipFound=0
        
        for query in queries:
            
            #print query.split("=")[0]
            if query[0]=="_" : query[0]="-"

            if query.split("=")[0].lower()=="-skip":

                skipFound=1
                query="-skip=%i"%newRangeStart
            newquery.append(query)

        if skipFound==0 :
            query="-skip=%i"%newRangeStart
            newquery.append(query)
                
        newquerystring=string.join(newquery,"&")
	
        return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
            
        
    def prevLink(self,html,storename="foundCount"):
        """prev link"""
        try:
            limit=self.REQUEST.SESSION[storename]['rangeSize']
            if int(limit)==0 :
                limit="1"
            newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])-int(limit)
        except:
            limit=1
            newRangeStart=0
        if newRangeStart <0:
            return ""

        #print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])
        
        if newRangeStart<0:
                newRangeStart=0

        #create new query string
        
        if self.REQUEST['QUERY_STRING']=="":
            qs=self.REQUEST.SESSION['query']
            #qs=re.sub(r'_','-',qs) #aendern für query
            queries=string.split(qs,",")
            
            
        else:
            qs=self.REQUEST['QUERY_STRING']
            queries=string.split(qs,"&")
            
            
            
        newquery=[]
        
        skipFound=0

        for query in queries:
            #print query.split("=")[0]

            if query[0]=="_" : query[0]="-"
            
            if query.split("=")[0].lower()=="-skip":
                #print"HI"
                query="-skip=%i"%newRangeStart
                skipFound=1
            newquery.append(query)

        if skipFound==0 :
            query="-skip=%i"%newRangeStart
            newquery.append(query)
            
        newquerystring=string.join(newquery,"&")

        return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)


    
    def prevLink_old(self,html):
        """prev link"""
        if self.REQUEST['QUERY_STRING']=="":
            qs=self.REQUEST.SESSION['query']
        else:
            qs=self.REQUEST['QUERY_STRING']
        max=re.search(r'max\=(.*)\,',qs.lower())
        offset=re.search(r'offset\=(.*)\,',qs.lower())
        if not offset:
            offsetnew=0
        else:
            offsetnew=int(offset)-max
            if offsetnew<0:
                offsetnew=0
        queries=string.split(qs,",")
        newquery=[]
        if offset:
            for query in queries:
                if query.split("=")[0].lower()=="offset":
                    query="-offset=%i"%offsetnew
                newquery.append(query)
                newquerystring=string.join(newquery,"&")
        else:
            queries.append("-offset=%i"%offsetnew)
            newquerystring=string.join(queries,"&")
        return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
        
    def nextLink_old(self,html):
        """prev link"""
        if self.REQUEST['QUERY_STRING']=="":
            qs=self.REQUEST.SESSION['query']
        else:
            qs=self.REQUEST['QUERY_STRING']
        max=re.search(r'max\=(.*)\,',qs.lower())
    
        offset=re.search(r'offset\=(.*)\,',qs.lower())
        if not offset:
            offsetnew=1
        else:
            offsetnew=int(offset)+int(max)
            if offsetnew<0:
                offsetnew=0
        queries=string.split(qs,",")
        newquery=[]
        if offset:
            for query in queries:

                if query.split("=")[0].lower()=="-offset":
                    query="-offset=%i"%offsetnew
                newquery.append(query)
                newquerystring=string.join(newquery,"&")
        else:
            queries.append("-offset=%i"%offsetnew)
            newquerystring=string.join(queries,"&")
        
        return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
        
    
manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())

def manage_addZSQLExtendFolder(self, id, title='', label='', description='',
                     createPublic=0,
                     createUserF=0,
                     connection_id=None,
                     REQUEST=None):
    """Add a new Folder object with id *id*.

    If the 'createPublic' and 'createUserF' parameters are set to any true
    value, an 'index_html' and a 'UserFolder' objects are created respectively
    in the new folder.
    """
    
    
    ob=ZSQLExtendFolder()
    ob.id=str(id)
    ob.title=title
    self._setObject(id, ob)
    ob=self._getOb(id)
    setattr(ob,'label',label)
    setattr(ob,'description',description)
    setattr(ob,'connection_id',connection_id)
    
    checkPermission=getSecurityManager().checkPermission

    if createUserF:
        if not checkPermission('Add User Folders', ob):
            raise Unauthorized, (
                  'You are not authorized to add User Folders.'
                  )
        ob.manage_addUserFolder()

    if createPublic:
        if not checkPermission('Add Page Templates', ob):
            raise Unauthorized, (
                  'You are not authorized to add Page Templates.'
                  )
        ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
            id='index_html', title='')

    if REQUEST is not None:
        return self.manage_main(self, REQUEST, update_menu=1)



class ZSQLBibliography(Folder,ZSQLExtendFolder):
    """Bibliography"""
    meta_type="ZSQLBibliography"
    def getLabel(self):
        try:
            return self.label
        except:
            return ""

    def getDescription(self):
        try:
            return self.description
        except:
            return ""
            
    def changeZSQLBibliographyForm(self):
        """change folder config"""
        pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLBibliographyForm.zpt').__of__(self)
        return pt()


    def content_html(self):
        """template fuer content"""
        
        try:
            obj=getattr(self,"ZSQLBibliography_template")
            return obj()
        except:
            pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt').__of__(self)
            pt.content_type="text/html"
            return pt()

    def changeZSQLBibliography(self,tableName,label,description,REQUEST=None):
        """change it"""
        self.tableName=tableName
        self.label=label
        self.description=description
        
        if REQUEST is not None:
            return self.manage_main(self, REQUEST)

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


    def getFieldLabel(self,fields,field):
        """get labels"""
        try:
            ret =fields[0][field]
            if ret == "":
                return field
            else:
                return ret
        except:
            return field
        
    def getFieldValue(self,found,field):
        """get value"""
        try:
            ret=getattr(found,field)
            if ret == "":
                return None
            else:
                return ret
        except:
            return None

    def findTagsFromMapping(self,referenceType):
        """gib hash mit label -> generic zurueck"""
        self.referencetypes=self.ZopeFind(self.standardMD)
        bibdata={}
        retdata={}
        fieldlist=self.standardMD.fieldList
        
	for referenceTypeF in self.referencetypes:
		#print referenceType,referenceTypeF[1].title
		if referenceTypeF[1].title == referenceType: 
			bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
			bibdata['data']=referenceTypeF[1]
			self.fields=bibdata[referenceType]
                        for field in fieldlist:
		            if referenceTypeF[1].getValue(field)[0]==None:
				retdata[field]=field
			    else:
                                retdata[field]=referenceTypeF[1].getValue(field)[0]

        return retdata,fieldlist
        
    def findLabelsFromMapping(self,referenceType):
        """gib hash mit label -> generic zurueck"""
        self.referencetypes=self.ZopeFind(self.standardMD)
        bibdata={}
        retdata={}
        fieldlist=self.standardMD.fieldList
        
	for referenceTypeF in self.referencetypes:
		#print referenceType,referenceTypeF[1].title
		if referenceTypeF[1].title == referenceType: 
			bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
			bibdata['data']=referenceTypeF[1]
			self.fields=bibdata[referenceType]
                        for field in fieldlist:
                            retdata[field]=referenceTypeF[1].getValue(field)[1]

        return retdata,fieldlist

    def createIndexTag(self,tag,content):
        """creste tag"""
        if content:
            ret="""<%s>%s</%s>"""%(tag,content,tag)
            return ret
        else:
            return ""
    
    def getMetaDataXML2(self):
        """crate index meta"""

        fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
        self.REQUEST['fn']=fn

        pt=PageTemplateFile('Products/ZSQLExtend/zpt/record2.xml').__of__(self)
        pt.content_type="text/xml"
        return pt()

    def getMetaDataXML(self):
        """crate index meta"""
        pt=PageTemplateFile('Products/ZSQLExtend/zpt/record.xml').__of__(self)
        pt.content_type="text/xml"
        return pt()

    def getMetaDatasXML(self):
        """index"""
        ret="""<?xml version="1.0" ?>
	             <index>"""
        for found in self.ZSQLSimpleSearch("select oid from %s limit ALL"%self.tableName):
            link=self.absolute_url()+"/"+"record.html?oid=%i"%found.oid
            metalink=self.absolute_url()+"/"+"getMetaDataXML?oid=%i"%found.oid
            
            ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)
            
        return ret+"\n</index>"

    
manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())

def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
                     createPublic=0,
                     createUserF=0,
                     REQUEST=None):
    """Add a new Folder object with id *id*.

    If the 'createPublic' and 'createUserF' parameters are set to any true
    value, an 'index_html' and a 'UserFolder' objects are created respectively
    in the new folder.
    """
    
    
    ob=ZSQLBibliography()
    ob.id=str(id)
    ob.title=title
    self._setObject(id, ob)
    ob=self._getOb(id)
    setattr(ob,'tableName',tableName)
    setattr(ob,'label',label)
    setattr(ob,'description',description)
    
    checkPermission=getSecurityManager().checkPermission

    if createUserF:
        if not checkPermission('Add User Folders', ob):
            raise Unauthorized, (
                  'You are not authorized to add User Folders.'
                  )
        ob.manage_addUserFolder()

    if createPublic:
        if not checkPermission('Add Page Templates', ob):
            raise Unauthorized, (
                  'You are not authorized to add Page Templates.'
                  )
        ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
            id='index_html', title='')

    if REQUEST is not None:
        return self.manage_main(self, REQUEST, update_menu=1)