[BACK]Return to ZSQLExtend.py CVS log [TXT] [DIR] Up to [Repository] / ZSQLExtend

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.104 and 1.108

version 1.104, 2007/02/20 17:19:38 version 1.108, 2007/04/02 12:34:51
Line 19  import os.path Line 19  import os.path
 import os  import os
 import copy  import copy
 import unicodedata  import unicodedata
   import tempfile
 import logging  import logging
   
 #ersetzt logging  #ersetzt logging
Line 70  def sql_quote(v): Line 70  def sql_quote(v):
 def showSQLConnectionIDs(self):  def showSQLConnectionIDs(self):
     return SQLConnectionIDs(self)      return SQLConnectionIDs(self)
   
   class Options:
       """options class"""
       
 class ZSQLIndex(SimpleItem):  class ZSQLIndex(SimpleItem):
     """index"""      """index"""
     meta_type="ZSQLIndex"      meta_type="ZSQLIndex"
Line 406  class ZSQLExtendFolder(Folder,Persistent Line 409  class ZSQLExtendFolder(Folder,Persistent
                 #print "wrote: %s"%fn                  #print "wrote: %s"%fn
   
   
     def importXMLFileFMP(self,table,data=None,filename=None,update_fields=None,id_field=None,sync_mode=False,RESPONSE=None):      def importXMLFileFMP(self,table,dsn=None,uploadfile=None,update_fields=None,id_field=None,sync_mode=False,replace=False,redirect_url=None,ascii_db=False,RESPONSE=None):
         '''          '''
         Import FileMaker XML file (FMPXMLRESULT format) into the table.          Import FileMaker XML file (FMPXMLRESULT format) into the table.
           @param dsn: database connection string
         @param table: name of the table the xml shall be imported into          @param table: name of the table the xml shall be imported into
         @param data: xml data as bz2 string          @param uploadfile: xmlfile file
         @param filename: xmlfile filename  
         @param update_fields: (optional) list of fields to update; default is to create all fields          @param update_fields: (optional) list of fields to update; default is to create all fields
         @param id_field: (optional) field which uniquely identifies an entry for updating purposes.          @param id_field: (optional) field which uniquely identifies an entry for updating purposes.
         @param sync_mode: (optional) really synchronise, i.e. delete entries not in XML file          @param sync_mode: (optional) really synchronise, i.e. delete entries not in XML file
         @param RESPONSE: (optional)          @param RESPONSE: (optional)
           @param redirect_url: (optional) url for redirecting after the upload is done
         '''          '''
         from xml.dom.pulldom import parseString,parse  
         import transaction  
   
         ret = ""  
   
         if data:  
             data=bz2.decompress(base64.decodestring(data))  
             logger("fmpxml",logging.INFO,"received file")  
             doc=parseString(data)  
             logger("fmpxml",logging.INFO,"parsed file")  
   
         elif filename:  
             fh=file(filename)  
             logger("fmpxml",logging.INFO,"reading file")  
             doc=parse(fh)  
             logger("fmpxml",logging.INFO,"parsed file")  
   
         dbIDs = {}  
         rowcnt = 0  
           
         if id_field is not None:  
             # prepare a list of ids for sync mode  
             qstr="select %s from %s"%(id_field,table)  
             for id in self.ZSQLSimpleSearch(qstr):  
                 # value 0: not updated  
                 dbIDs[id[0]] = 0;  
                 rowcnt += 1  
                   
             logger("fmpxml",logging.INFO,"%d entries in DB to sync"%rowcnt)  
           
         fieldNames = []  
         rowcnt = 0  
         id_val = ''  
           
         while 1:  
             node=doc.getEvent()  
           
             if node is None:  
                 break;  
               
             # METADATA tag defines number and names of fields in FMPXMLRESULT  
             if node[1].nodeName == 'METADATA':  
                 doc.expandNode(node[1])  
               
                 names=node[1].getElementsByTagName('FIELD')  
   
                 for name in names:  
                     fn = name.getAttribute('NAME')  
                     fieldNames.append(fn)  
                   
                 if update_fields is None:  
                     # update all fields  
                     update_fields = fieldNames  
                   
                 logger("fmpxml fieldnames:",logging.INFO,repr(fieldNames))  
                 # get list of fields in db table  
                 qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s'"""  
                 columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]  
                   
                 # adjust db table to fields in XML and fieldlist  
                 for fieldName in fieldNames:  
                     logger("fmpxml fieldname:",logging.INFO,repr(fieldName))                       
                     if (fieldName not in columns) and (fieldName in update_fields):  
                         qstr="""alter table %s add %s %s"""  
                         self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))  
                         logger("fmpxml add field:",logging.INFO,qstr%(table,fieldName,'text'))  
                           
             # ROW tags (in RESULTSET tag) hold data  
             elif node[1].nodeName == 'ROW':  
                 rowcnt += 1  
                   
                 doc.expandNode(node[1])  
                 cols=node[1].getElementsByTagName('COL')  
                 dataSet={}  
                 i = 0  
                 # populate with data  
                 for col in cols:  
                     data=col.getElementsByTagName('DATA')  
                     dataSet[fieldNames[i]] = getTextFromNode(data[0])  
                     i += 1  
                                           
                 update=False          tfilehd,filename=tempfile.mkstemp()
                           tfile=os.fdopen(tfilehd,'w')
                 # synchronize by id_field          logging.error("import %s"%uploadfile)
                 if id_field:          for c in uploadfile.read():
                     id_val=dataSet[id_field]              tfile.write(c)
                     if id_val in dbIDs:          tfile.close()  
                         dbIDs[id_val] += 1          
                         update=True          from importFMPXML import importFMPXML
                           
                 if update:          if not dsn:
                     # update existing row (by id_field)              dsn=self.getConnectionObj().connection_string
                     setvals=[]              
                     for fieldName in update_fields:          options=Options()
                         setvals.append("%s = %s"%(fieldName,self.ZSQLQuote(dataSet[fieldName])))          options.dsn=dsn
                     setStr=string.join(setvals, ',')          options.table=table
                     id_val=dataSet[id_field]          options.filename=filename
                     qstr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,id_field,id_val)          options.update_fields=update_fields
                     #logger("fmpxml update:",logging.INFO,queryStr)          options.id_field=id_field
                     self.ZSQLSimpleSearch(qstr)          options.sync_mode=sync_mode
                     ret+="up: %s \n"%id_val          options.replace_table=replace
                 else:          options.lc_names=True
                     # create new row      options.ascii_db=ascii_db
                     fields=string.join(update_fields, ',')          importFMPXML(options)
                     values=string.join([" %s "%self.ZSQLQuote(dataSet[x]) for x in update_fields], ',')  
                     qstr="""INSERT INTO %s (%s) VALUES (%s)"""%(table,fields,values)  
                     self.ZSQLSimpleSearch(qstr)  
                     #logger("fmpxml: insert",logging.INFO,queryStr)  
                     ret+="ad: %s \n"%dataSet.get(id_field, rowcnt)  
   
                 #logger("fmpxml row:",logging.INFO,"%d (%s)"%(rowcnt,id_val))  
                 if (rowcnt % 10) == 0:  
                     logger("fmpxml row:",logging.INFO,"%d (%s)"%(rowcnt,id_val))  
                     transaction.commit()  
   
         transaction.commit()  
         if sync_mode:  
             # delete unmatched entries in db  
             for id in dbIDs.keys():  
                 # find all not-updated fields  
                 if dbIDs[id] == 0:  
                     logger("fmpxml delete:",logging.INFO,id)  
                     qstr = "DELETE FROM %s WHERE %s = '%s'"  
                     self.ZSQLSimpleSearch(qstr%(table,id_field,id))  
                                           
                 elif dbIDs[id] > 1:          os.remove(filename)
                     logger("fmpxml sync:",logging.INFO,"id used more than once?"+id)  
                           
             transaction.commit()          if RESPONSE and redirect_url:
                           RESPONSE.redirect(redirect_url)
         return ret          
                   
     def generateIndex(self,field,index_name,table,RESPONSE=None):      def generateIndex(self,field,index_name,table,RESPONSE=None):
         """erzeuge index aus feld"""          """erzeuge index aus feld"""
Line 784  class ZSQLExtendFolder(Folder,Persistent Line 686  class ZSQLExtendFolder(Folder,Persistent
         ret+="""</select>"""          ret+="""</select>"""
         return ret          return ret
   
     def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None,additionalSelect="",size=None,linelen=None,selected=None):      def ZSQLOptionsFromSearchList(self,fieldname,
                                     results,fieldName,
                                     valueName=None,start=None, 
                                     multiple='',startValue=None,
                                     additionalSelect="",size=None,
                                     linelen=None,selected=None):
         """generate select options form a search list          """generate select options form a search list
         es wird          es wird
         <select name=fieldname mutiple>          <select name=fieldname mutiple>
Line 797  class ZSQLExtendFolder(Folder,Persistent Line 704  class ZSQLExtendFolder(Folder,Persistent
         @parameter fieldName: Name des Feldes, das als value in den option-tag geschrieben werden soll.          @parameter fieldName: Name des Feldes, das als value in den option-tag geschrieben werden soll.
         @parameter valueName: (optional) Name des Feldes, dass als im option-tag ausgegeben wird, default wert ist valueName=fieldName          @parameter valueName: (optional) Name des Feldes, dass als im option-tag ausgegeben wird, default wert ist valueName=fieldName
         @start: (optional) falls zusaetzliches option tag erzeugt werden soll, gibt start an was im option tag steht          @start: (optional) falls zusaetzliches option tag erzeugt werden soll, gibt start an was im option tag steht
         @startValue: gibt den entsprechenden Wert an.          @startValue (optional): gibt den entsprechenden Wert an.
           @selected (optional): Wert der ausgewaehlt sein soll.
         @linelen: (optional) maximale laenge eines Eintrages           @linelen: (optional) maximale laenge eines Eintrages 
                     der im Klappmenue noch angezeigt wird, laengeres wird abgeschnitten.                      der im Klappmenue noch angezeigt wird, laengeres wird abgeschnitten.
           @addionalSaelect (optional): zusaetzlicher text fuer den select tag
         """          """
         if not valueName:          if not valueName:
             valueName=fieldName              valueName=fieldName
Line 817  class ZSQLExtendFolder(Folder,Persistent Line 726  class ZSQLExtendFolder(Folder,Persistent
                     startValue=start                      startValue=start
                                                           
             ret+="""<option value="%s" >%s</option>"""%(startValue,start)              ret+="""<option value="%s" >%s</option>"""%(startValue,start)
         
         for result in results:          for result in results:
             field=getattr(result,fieldName)              field=getattr(result,fieldName)
             fieldValue=getattr(result,valueName)              fieldValue=getattr(result,valueName)
   
             if fieldValue:              if linelen and fieldValue and (len(fieldValue) > string.atoi(linelen)):
                                  displayValue = fieldValue[:string.atoi(linelen)]
                 if not linelen:              else: 
                   displayValue = fieldValue
   
                                           
                     if field == selected:                      if field == selected:
   
                         ret+="""<option value="%s" selected>%s</option>"""%(field,fieldValue)                  ret+="""<option value="%s" selected>%s</option>"""%(field,displayValue)
                     else:                      else:
                         ret+="""<option value="%s">%s</option>"""%(field,fieldValue)                  ret+="""<option value="%s">%s</option>"""%(field,displayValue)
   
                 else:  
                     mist = """%s"""%(fieldValue)  
                     if len(mist) > string.atoi(linelen):  
                         mist = mist[:string.atoi(linelen)]  
                     ret+="""<option value="%s">%s</option>"""%(field,mist)  
         ret+="""</select>"""          ret+="""</select>"""
         return ret          return ret
   
Line 1155  class ZSQLExtendFolder(Folder,Persistent Line 1061  class ZSQLExtendFolder(Folder,Persistent
           
               
           
     def ZSQLFind(self,qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,**argv):      def ZSQLFind(self,qs="",select="oid,*",storename="foundCount",tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,**argv):
         """search in database"""          """search in database"""
   
         def delEmpty(list):          def delEmpty(list):
Line 1207  class ZSQLExtendFolder(Folder,Persistent Line 1113  class ZSQLExtendFolder(Folder,Persistent
   
         qs=string.join(delEmpty(qs.split(",")),",")          qs=string.join(delEmpty(qs.split(",")),",")
   
         if storename:  
             """store"""  
         else:  
             storename="foundCount"  
   
         #store query for further usage          #store query for further usage
           #TODO: erste der beiden ist ueberfluessig
         self.REQUEST.SESSION['query']=qs          self.REQUEST.SESSION['query']=qs
           if not self.REQUEST.SESSION.has_key(storename):
                   self.REQUEST.SESSION[storename]={}
                   
           self.REQUEST.SESSION[storename]['qs']=qs
           
   
         #print "calling Query with",repr(NoQuery)          #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)          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"]          #print self.REQUEST.SESSION["foundCount"]
                   
                   
   
         return ret          return ret
   
     def ZSQLFoundCountLen(self,var):      def ZSQLFoundCountLen(self,var):
         return len(var)          return len(var)
                           
     def ZSQLFoundCount(self,qs="",select="*",storename=None):      def ZSQLFoundCount(self,qs="",select="*",storename="foundCount"):
           
        ##  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']          return self.REQUEST.SESSION[storename]['count']
   
     def ZSQLRangeStart(self,storename=None):      def ZSQLRangeStart(self,storename="foundCount"):
           
         if storename:  
             """store"""  
         else:  
             storename="foundCount"  
                   
         return int(self.REQUEST.SESSION[storename]['rangeStart'])+1          return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
           
     def ZSQLRangeSize(self,storename=None):      def ZSQLRangeSize(self,storename="foundCount"):
           
         if storename:  
             """store"""  
         else:  
             storename="foundCount"  
                           
         return self.REQUEST.SESSION[storename]['rangeSize']          return self.REQUEST.SESSION[storename]['rangeSize']
   
     def ZSQLRangeEnd(self,storename=None):      def ZSQLRangeEnd(self,storename="foundCount"):
           
         if storename:  
             """store"""  
         else:  
             storename="foundCount"  
                   
         return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))          return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))
   
     def ZSQLNewQuery(self,linkText,storename=None,**argv):      def ZSQLNewQuery(self,linkText,storename="foundCount",**argv):
         """suche neu"""          """suche neu"""
         return self.ZSQLNewSearch(linkText,storename,url=self.REQUEST['URL'],args=argv)          return self.ZSQLNewSearch(linkText,storename,url=self.REQUEST['URL'],args=argv)
           
     def ZSQLNewSearch(self,linkText,storename=None,url=None,args=None,**argv):      def ZSQLNewSearch(self,linkText,storename="foundCount",url=None,args=None,**argv):
         """suche mit alten parametern bis auf die in argv getauschten"""          """suche mit alten parametern bis auf die in argv getauschten"""
         str = self.ZSQLNewSearchURL(storename, url, args, **argv)          str = self.ZSQLNewSearchURL(storename, url, args, **argv)
         return """<a href="%s"> %s</a>"""%(str,linkText)          return """<a href="%s"> %s</a>"""%(str,linkText)
                   
   
     def ZSQLNewSearchURL(self, storename=None,url=None,args=None,**argv):      def ZSQLNewSearchURL(self, storename="foundCount",url=None,args=None,**argv):
         """suche mit alten parametern bis auf die in argv getauschten"""          """suche mit alten parametern bis auf die in argv getauschten"""
                   
         if storename:   
             """store"""    
         else:  
             storename="foundCount"  
         qs=self.REQUEST.SESSION[storename]['qs']  
           
         if args:          if args:
             argv=args              argv=args
                           
           #get the old queries
           qs=self.REQUEST.SESSION[storename]['qs']
         querys=qs.split(",")          querys=qs.split(",")
         argList=[]  
         arg=""  
         queryList=[x.split("=")[0] for x in querys]  
                   
         for argTmp in argv.keys():          #which arguments are in the old query string
                           
           queryList={}
           for query in querys:
               arg=query.split("=")[0]
               if arg[0]=="_": arg="-"+arg[1:] # sicherstellen, dass an Anfang stets "_"
               queryList[arg]=query.split("=")[1]
                           
             arg=argTmp[0:]  
                           
           argList=[]
           arg=""
   
             if arg not in queryList: # noch nicht drin  
                 querys.append("%s=%s"%(arg,argv[argTmp]))  
             argList.append(arg)  
   
   
           #gehe durch die zu aendernden Argumente
           for argTmp in argv.keys():
                   
         newquery=[]              arg=argTmp[0:]# sicherstellen, dass der string auh kopiert wird
         for query in querys:              if arg[0]=="_": arg="-"+arg[1:] # sicherstellen, dass an Anfang stets "_"            
             queryArg=query.split("=")[0]  
             qarg=queryArg[0:]  
             if qarg[0]=="-":qarg="_"+queryArg[1:] # aender _ in - als standard  
                           
             if  queryArg in argList:              queryList[arg]=argv[argTmp]
                 newquery.append("%s=%s"%(queryArg,argv[qarg]))  
             else:  
                 newquery.append(query)  
   
         if url:          if url:
             str=url+"?"+"&".join(newquery)              str=url+"?"+urllib.urlencode(queryList)
         else:          else:
             str="ZSQLSearch?"+"&".join(newquery)              str="ZSQLSearch?"+urllib.urlencode(queryList)
                   
         return str          return str
           
     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):      def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename="foundCount",tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None):
         """analysieren den QueryString"""          """analysieren den QueryString"""
                 
                 
Line 1357  class ZSQLExtendFolder(Folder,Persistent Line 1221  class ZSQLExtendFolder(Folder,Persistent
         searchFieldsOnly={}          searchFieldsOnly={}
         queryTemplate=[]          queryTemplate=[]
         outerjoin=""          outerjoin=""
           debug=None
                   
         if not select:          if not select:
             select="oid,*"              select="oid,*"
Line 1375  class ZSQLExtendFolder(Folder,Persistent Line 1240  class ZSQLExtendFolder(Folder,Persistent
         for q in splitted:          for q in splitted:
                                   
                 name=re.sub("r'+'"," ",q.split("=")[0].lower())                  name=re.sub("r'+'"," ",q.split("=")[0].lower())
                   if name=="_debug":
                       debug=True
                       
                 try:                  try:
                     value=urllib.unquote(q.split("=",1)[1])                      value=urllib.unquote(q.split("=",1)[1])
                 except:                  except:
Line 1612  class ZSQLExtendFolder(Folder,Persistent Line 1480  class ZSQLExtendFolder(Folder,Persistent
             self.REQUEST.SESSION['qs']=opfields              self.REQUEST.SESSION['qs']=opfields
         #print "IAMHERE again:", query          #print "IAMHERE again:", query
   
         if storename and (not NoQuery):          if not NoQuery:
   
             query2="SELECT count(*) FROM %s %s"%(table,where)              query2="SELECT count(*) FROM %s %s"%(table,where)
                           
Line 1637  class ZSQLExtendFolder(Folder,Persistent Line 1505  class ZSQLExtendFolder(Folder,Persistent
   
                 self.REQUEST.SESSION[storename]['queryString2']=query2                  self.REQUEST.SESSION[storename]['queryString2']=query2
                 if self.ZSQLSimpleSearch(query2):                  if self.ZSQLSimpleSearch(query2):
           
                     self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count                      self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
                 else:                  else:
                     self.REQUEST.SESSION[storename]['count']=0                      self.REQUEST.SESSION[storename]['count']=0
Line 1644  class ZSQLExtendFolder(Folder,Persistent Line 1513  class ZSQLExtendFolder(Folder,Persistent
                           
                           
             self.REQUEST.SESSION[storename]['rangeStart']=rangeStart              self.REQUEST.SESSION[storename]['rangeStart']=rangeStart
             if limit=="all":              
               
               self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
               
               if (limit=="all") or (limit==int(limit)):
                 self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']                  self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
             else:              else:
                 self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)                  self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
Line 1653  class ZSQLExtendFolder(Folder,Persistent Line 1526  class ZSQLExtendFolder(Folder,Persistent
   
             self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly              self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly
           
           if debug:
               logging.error("ZSQLSimpleSearch %s"%query)
         if not NoQuery:          if not NoQuery:
                                   
             return self.ZSQLQuery(query)              return self.ZSQLQuery(query)
Line 1737  class ZSQLExtendFolder(Folder,Persistent Line 1612  class ZSQLExtendFolder(Folder,Persistent
             limit=1              limit=1
             newRangeStart=0              newRangeStart=0
                           
         if newRangeStart>=self.REQUEST.SESSION[storename]['count']:          if (newRangeStart>=self.REQUEST.SESSION[storename]['count']) or (self.REQUEST.SESSION[storename]['count']==self.REQUEST.SESSION[storename]['rangeEnd']):
             #newRangeStart=self.REQUEST.SESSION[storename]['count']-1              #newRangeStart=self.REQUEST.SESSION[storename]['count']-1
             return ""              return ""
                   
Line 1836  class ZSQLExtendFolder(Folder,Persistent Line 1711  class ZSQLExtendFolder(Folder,Persistent
   
   
           
     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())  manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())
   
Removed from v.1.104  
changed lines
  Added in v.1.108

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