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

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.80 and 1.143

version 1.80, 2006/04/20 14:08:35 version 1.143, 2012/02/15 08:08:42
Line 4  from Globals import DTMLFile,package_hom Line 4  from Globals import DTMLFile,package_hom
 import urllib  import urllib
 import re  import re
 import string  import string
 import sys  
 #from pyPgSQL import libpq  #from pyPgSQL import libpq
 from AccessControl import getSecurityManager  import psycopg2
   from AccessControl import getSecurityManager,Unauthorized
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   
 from Products.ZSQLMethods.SQL import SQLConnectionIDs  from Products.ZSQLMethods.SQL import SQLConnectionIDs
   from Shared.DC.ZRDB.Results import Results
   
 from xml.sax.saxutils import escape  from xml.sax.saxutils import escape
 from types import *  from types import *
 import Shared.DC.ZRDB.DA  import Shared.DC.ZRDB.DA
 import zLOG  import logging
 import os.path  import os.path
 import os  import os
   import copy
   import unicodedata
   import tempfile
   import sys
   
   #ersetzt logging
   def logger(txt,method,txt2):
       """logging""" 
       logging.info(txt+ txt2)
   
   
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
   
 def getTextFromNode(nodename):  def getTextFromNode(nodename):
       """get the cdata content of a node"""
       if nodename is None:
           return ""
     nodelist=nodename.childNodes      nodelist=nodename.childNodes
     rc = ""      rc = ""
     for node in nodelist:      for node in nodelist:
Line 27  def getTextFromNode(nodename): Line 43  def getTextFromNode(nodename):
            rc = rc + node.data             rc = rc + node.data
     return rc      return rc
   
       
 def analyseIntSearch(word):  def analyseIntSearch(word):
     #analyse integer searches      #analyse integer searches
   
Line 44  def analyseIntSearch(word): Line 59  def analyseIntSearch(word):
     else:      else:
         return "BETWEEN "+splitted[0]+" AND "+splitted[1]          return "BETWEEN "+splitted[0]+" AND "+splitted[1]
   
   def unicodify(str):
       """decode str (utf-8 or latin-1 representation) into unicode object"""
       if not str:
           return u""
       if type(str) is StringType:
           try:
               return str.decode('utf-8')
           except:
               return str.decode('latin-1')
       else:
           return str
   
   def utf8ify(str):
       """encode unicode object or string into byte string in utf-8 representation"""
       if not str:
           return ""
       if type(str) is StringType:
           return str
       else:
           return str.encode('utf-8')
   
   
   def setPsycopg2UseUnicode():
       """force Psycopg2DA to return unicode objects"""
       try:
           import psycopg2
           import psycopg2.extensions
           psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
       except:
           logging.error("Unable to force psycopg2 to use unicode")
                   
   
 def sql_quote(v):  def sql_quote(v):
Line 57  def sql_quote(v): Line 102  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 73  class ZSQLIndex(SimpleItem): Line 121  class ZSQLIndex(SimpleItem):
         return self.index          return self.index
   
 class ZSQLExtendFolder(Folder,Persistent, Implicit):  class ZSQLExtendFolder(Folder,Persistent, Implicit):
     """Folder"""      """Klasse die Methoden fuer die Abfrage einer SQL-Datenbank zur Verfuegung stellt.
       
       """
     meta_type="ZSQLExtendFolder"      meta_type="ZSQLExtendFolder"
           
     def ZSQLQuote(self,str):      def ZSQLQuote(self,str):
         """quote str for sql"""          """quote str for sql"""
         return sql_quote(str)          return sql_quote(str)
           
       def unicodify(self, s):
           """return unicode object for string (utf-8 or latin1) or unicode object s"""
           return unicodify(s)
       
       def utf8ify(self, s):
           """return utf-8 encoded string object for string or unicode object s"""
           return utf8ify(s)
   
      
       def normalizeField(self,table,fieldname, newFieldName=None,mode="alter", RESPONSE=None):
           """normalize a field, d.h. entfernt alle diakritischen Zeichen und ersetzt diese 
           durch den Grundbuchstaben in einer Spalte einer Tabelle
           @param table: Tabellename
           @param fieldname: Name der Spalte
           @param newFieldName: (optional) default ist fieldname+"_normal"
           @param mode: (optional) default ist "alter". Mode "alter" aendert ein bestehendes Feld newFieldName, mode "create" erzeugt diese zuerst. 
           """
           import unicodedata
           
           if not newFieldName:
               newFieldName=fieldname+"_normal"
          
          #normalisierungs routine 
           def normal(str):
               if str:
                   return unicodedata.normalize('NFKD', str.decode('utf-8')).encode('ASCII', 'ignore')
               else:
                   return ""
               
           if mode=="create": # create the field
               qstr="""alter table %s add %s %s"""
               self.ZSQLSimpleSearch(qstr%(table,newFieldName,'text'))
           
           qstr="select oid,%s from %s"%(fieldname,table)
           for result in self.ZSQLSimpleSearch(qstr):
               qstr="update %s set %s = %s where oid = %s"
   
               self.ZSQLSimpleSearch(qstr%(table,newFieldName,self.ZSQLQuote(normal(getattr(result,fieldname))),result.oid))
           
       def importAccessModell(self,configFileName,RESPONSE=None):
           """import tables from access
           @param configFileName: xml-configfile
           """
           from Ft.Xml import Parse
           fh=file(configFileName)
   
           doc=Parse(fh)
           
           x=doc.xpath("//pathToFolder/@path")
           
           
           if not (len(x)==1): # tag ist nich eineindeutig
               return False
           
           pathToFolder=x[0].value
           
           for db in doc.xpath("//db"):
   
               containers=db.xpath("./@container")
               identifiers=db.xpath("./@identify")
           
     def importXMLFile(self,table,data=None,identify=None,filename=None,RESPONSE=None):  
         #TODO: finish importXMLFile              if not (len(containers)==1):
                   return False
               else:
                   container=containers[0].value
               
               if not (len(identifiers)==1):
                   identifier=None
               else:
                   identifier=identifiers[0].value
               
               self.xsdToTable(container.lower(),container,modus="drop",filename=os.path.join(pathToFolder,container.lower()+".xsd"))
               self.importXMLFileAccess(container.lower(),container,filename=os.path.join(pathToFolder,container.lower()+".xml"),identify=identifier)
               
           return "<html><body>DONE</body></html>"
        
       def xsdToTable(self,table,elementNameForTable,modus="update", filename=None,data=None,RESPONSE=None):
           """reads an xsd file an creates the columns of a table out of its structure
           @param table: name of the table the xml shall be imported into
           @param elementNameForTable: must be a element of type complex type. the element of the sequence in the complex type
                                       define the columns of the table >table<
           @param data (optional): data to be imported
       
           @param filename (optional) or filename
           @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
           @param RESPONSE: (optional)
    
           """
           #from xml.dom.minidom import parseString,parse
           
           from Ft.Xml import Parse
           logger("import xsd",logging.INFO,"called")
           #fh=file("/tmp/fmpxml.xml")
           import bz2
           import base64
           
           
           ret=""
           if data:
             data=bz2.decompress(base64.decodestring(data))
           
             #logger("import xsd",logging.INFO,"received file")
             doc=Parse(data)
             #logger("import xsd",logging.INFO,"parsed file")
           
           elif filename:
             fh=file(filename)
             txt=fh.read()
             
             doc=Parse(txt)
             #logger("import xsd",logging.INFO,"parsed file")
           
           
           Nss={'xsd':'http://www.w3.org/2001/XMLSchema'}
           definingSequence=doc.xpath("""//xsd:element[@name='%s']/xsd:complexType/xsd:sequence/xsd:element/@name"""%elementNameForTable,explicitNss=Nss)
           
           fieldNames=[x.value for x in definingSequence]
           
           
           
           #check if table exists
           
           qstr="""select relname from pg_class where relname = '%s'"""%table
           if not(self.ZSQLSimpleSearch(qstr)) or (len (self.ZSQLSimpleSearch(qstr))<1): # if not the create the table
               columns=[]
               create=True    
           else:
               create=False
               
               logger("update xsd: fieldnames",logging.INFO,repr(fieldNames))                       
               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)]            
           
           
           if (modus=="drop") and (not create): #table shall be deleted, therefore it should exist (not create)
               print "drop"
               qstr="""DROP TABLE %s """
               self.ZSQLSimpleSearch(qstr%table)
               columns=[]
               create=True
           
           for fieldName in fieldNames:
               if type(fieldName) is UnicodeType:
                   fieldName=fieldName.encode('utf-8')
               logging.info("update xml: fieldname",logging.INFO,repr(fieldName))                     
               if fieldName.lower() not in columns:
                   
                   if create:# table does not exist therefore create with one column
                       qstr="""create table %s (%s %s)"""
                       create=False
                   else:# otherwise add the field
                       qstr="""alter table %s add %s %s"""
                   
                   self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
                   logger("update xsd: fieldname add",logging.INFO,qstr%(table,fieldName,'text'))                       
      
   
       def importXMLFileAccess(self,table,container,data=None,identify=None,filename=None,RESPONSE=None):
         '''          '''
         Import XML file into the table          Import XML file in access format into the table
         @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 containerTagName: XML-Tag which describes a dataset          @param containerTagName: XML-Tag which describes a dataset
         @param data: data to be imported          @param data: data to be imported
Line 94  class ZSQLExtendFolder(Folder,Persistent Line 299  class ZSQLExtendFolder(Folder,Persistent
         '''          '''
         from xml.dom.pulldom import parseString,parse          from xml.dom.pulldom import parseString,parse
                   
         zLOG.LOG("import xml",zLOG.INFO,"called")          logger("import xml",logging.INFO,"called")
         #fh=file("/tmp/fmpxml.xml")          #fh=file("/tmp/fmpxml.xml")
         import bz2          import bz2
         import base64          import base64
Line 103  class ZSQLExtendFolder(Folder,Persistent Line 308  class ZSQLExtendFolder(Folder,Persistent
         if data:          if data:
           data=bz2.decompress(base64.decodestring(data))            data=bz2.decompress(base64.decodestring(data))
           
           zLOG.LOG("import xml",zLOG.INFO,"received file")            logger("import xml",logging.INFO,"received file")
           doc=parseString(data)            doc=parseString(data)
           zLOG.LOG("import xml",zLOG.INFO,"parsed file")            logger("import xml",logging.INFO,"parsed file")
   
     elif filename:      elif filename:
       fh=file(filename)        fh=file(filename)
       doc=parse(fh)        doc=parse(fh)
           zLOG.LOG("import xml",zLOG.INFO,"parsed file")            logger("import xml",logging.INFO,"parsed file")
         while 1:          while 1:
             node=doc.getEvent()              node=doc.getEvent()
                           
             if node is None:              if node is None:
                 break;                  break;
             else:              else:
                 if node[1].nodeName=='ROW':                  if node[1].nodeName.lower()==container.lower(): # make everything case insensitive
                     doc.expandNode(node[1])                      doc.expandNode(node[1])
                     cols=node[1].getElementsByTagName('COL')                      
                     dataSet=[]                      dataSet={}
                     for col in cols:                      for col in node[1].childNodes:
                         data=col.getElementsByTagName('DATA')                          if col.nodeType is col.ELEMENT_NODE: 
                         dataSet.append(getTextFromNode(data[0]))                              data=col.nodeName
                               dataSet[data]=getTextFromNode(col)
   
                     update=False                      update=False
                       
                     if identify:                      if identify:
   
                         nr=fieldNames.index(identify)                          field=dataSet[identify]
                         field=dataSet[nr]  
   
                         searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)                          searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)
                         zLOG.LOG("import xml",zLOG.INFO,searchStr)                          logger("import xml",logging.INFO,searchStr)
                         search=self.ZSQLSimpleSearch(searchStr)                          search=self.ZSQLSimpleSearch(searchStr)
                         if search:                          if search:
                             update=True                              update=True
                                           
                     if update:                      if update:
                         tmp=[]                          tmp=[]
                         for fieldName in fieldNames:                          for fieldName in dataSet.keys():
                             tmp.append("""%s = %s"""%(fieldName,self.ZSQLQuote(dataSet[fieldNames.index(fieldName)])))                              tmp.append("""%s = %s"""%(fieldName,self.ZSQLQuote(dataSet[fieldName])))
                         setStr=",".join(tmp)                          setStr=",".join(tmp)
                         nr=fieldNames.index(identify)  
                         field=dataSet[nr]                          field=dataSet[identify]
                                       
                         queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)                          queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)
                         zLOG.LOG("update xml",zLOG.INFO,queryStr)                          logger("update xml",logging.INFO,queryStr)
                         self.ZSQLSimpleSearch(queryStr)                          self.ZSQLSimpleSearch(queryStr)
                         ret+="ud: %s \n"%field                          ret+="ud: %s \n"%field
                     else:  
   
                                              else:
                         fields=",".join(fieldNames)                          fields=",".join(dataSet.keys())
                         values=",".join([""" %s """%self.ZSQLQuote(x) for x in dataSet])                          values=",".join([""" %s """%self.ZSQLQuote(dataSet[x]) for x in dataSet.keys()])
                                       
                                                   
                         queryStr="""INSERT INTO %s  (%s) VALUES (%s)"""%(table,fields,values)                          queryStr="""INSERT INTO %s  (%s) VALUES (%s)"""%(table,fields,values)
                         self.ZSQLSimpleSearch(queryStr)                          self.ZSQLSimpleSearch(queryStr)
                         zLOG.LOG("update xml",zLOG.INFO,queryStr)                          logger("update xml",logging.INFO,queryStr)
                         ret+="ad: %s \n"%field  
                                                   
                 elif node[1].nodeName=="METADATA":          return ret
                     fieldNames=[]  
                     doc.expandNode(node[1])  
                                   
                     names=node[1].getElementsByTagName('FIELD')  
   
                     for name in names:      def importXMLFileFMP(self,table,dsn=None,uploadfile=None,update_fields=None,id_field=None,sync_mode=False,
                         fieldNames.append(name.getAttribute('NAME'))                           lc_names=True,keep_fields=False,ascii_db=False,replace=False,backup=False,
                            debug=False,log_to_response=False,
                            redirect_url=None,RESPONSE=None):
           """
           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 (may be comma-separated list)
           @param uploadfile: xmlfile file
           @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 sync_mode: (optional) really synchronise, i.e. delete entries not in XML file
           @param lc_names: (optional) lower case and clean up field names from XML
           @param keep_fields: (optional) don't add fields to SQL database
           @param ascii_db: (optional) assume ascii encoding in db
           @param replace: (optional) delete and re-insert data
           @param backup: (optional) create backup of old table (breaks indices)
           @param RESPONSE: (optional)
           @param redirect_url: (optional) url for redirecting after the upload is done
           """
                           
             zLOG.LOG("update xml: fieldnames",zLOG.INFO,repr(fieldNames))                     tfilehd,filename=tempfile.mkstemp()
                     qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s' """          tfile=os.fdopen(tfilehd,'w')
                     columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]          logging.info("importXMLFileFMP: importing %s"%uploadfile)
           for c in uploadfile.read():
               tfile.write(c)
           tfile.close()  
           
           from importFMPXML import importFMPXML
           
           if not dsn:
               dsn=self.getConnectionObj().connection_string
           
           logging.debug("dsn: %s"%dsn)
           logging.debug("table: %s"%table)
           logging.debug("update_fields: %s"%update_fields)
           logging.debug("id_field: %s"%id_field)
           logging.debug("sync_mode: %s"%sync_mode)
           logging.debug("lc_names: %s"%lc_names)
           logging.debug("keep_fields: %s"%keep_fields)
           logging.debug("ascii_db: %s"%ascii_db)
           logging.debug("replace: %s"%replace)
           logging.debug("backup: %s"%backup)
           logging.debug("debug: %s"%debug)
           logging.debug("log_to_response: %s"%log_to_response)
           logging.debug("RESPONSE: %s"%repr(RESPONSE))
   
           tablelist=table.split(',')
           logging.debug("tablelist: %s"%tablelist)
           #table=tables
           
           for t in tablelist :   
               logging.debug("table: %s"%table)  
               options=Options()
               options.dsn=dsn
               options.table=t
               options.filename=filename
               options.update_fields=update_fields
               options.id_field=id_field
               options.sync_mode=sync_mode
               options.lc_names=lc_names
               options.replace_table=replace
               options.keep_fields=keep_fields
               options.ascii_db=ascii_db
               options.replace_table=replace
               options.backup_table=backup
               options.debug=debug
               logging.debug(options)
               if RESPONSE and log_to_response:
                   # set up logging to response as plain text
                   logging.debug("Setting up logging to RESPONSE")
                   RESPONSE.setHeader("Content-Type","text/plain; charset=utf-8")
                   RESPONSE.write("Import FMPXML file...\n\n")
                   RESPONSE.flush()
                   loghandler = logging.StreamHandler(RESPONSE)
                   if debug:
                       loghandler.setLevel(logging.DEBUG)
                   else:
                       loghandler.setLevel(logging.INFO)
                   logger = logging.getLogger('db.import.fmpxml')
                   logger.addHandler(loghandler)
                   options.use_logger_instance = logger
   
               try:
                   err = None
                   importFMPXML(options)
                   logging.info("importXMLFileFMP: done")
               except Exception, err:
                   logging.error("Error importing: %s"%err)                                    
               
               if RESPONSE and log_to_response:
                   loghandler.flush()
                   if err is not None:
                       RESPONSE.write("\n\nERROR while importing: %s"%err)
                   else:
                       RESPONSE.write("\n\n DONE!")
                
               elif RESPONSE and redirect_url:
                   RESPONSE.redirect(redirect_url)
                   
           os.remove(filename)
                                     
                     for fieldName in fieldNames:  
                     zLOG.LOG("update xml: fieldname",zLOG.INFO,repr(fieldName))           
                         if fieldName not in columns:  
                             qstr="""alter table %s add %s %s"""  
                             self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))  
                             zLOG.LOG("update xml: fieldname add",zLOG.INFO,qstr%(table,fieldName,'text'))             
                 #fn=node[1].getAttribute("xml:id")  
                 #nf=file("xtf/"+fn+".xtf",'w')  
                 #nf.write("""<texts xmlns="http://emegir.info/xtf" xmlns:lem="http://emegir.info/lemma" >"""+node[1].toxml()+"</texts>")  
                 #print "wrote: %s"%fn  
         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 ein Index Objekt einem Feld (experimental)
           @param field: Feldname zu dem ein Index erzeugt werden soll
           @param index_name: Name des Index
           @param table: Tabellen name"""
           
           
         index={}          index={}
         founds=self.ZSQLSimpleSearch("""SELECT %s,oid FROM %s LIMIT 2000"""%(field,table))          founds=self.ZSQLSimpleSearch("""SELECT %s,oid FROM %s """%(field,table))
   
         for found in founds:          for found in founds:
             tmp=getattr(found,field,None)              tmp=getattr(found,field,None)
Line 208  class ZSQLExtendFolder(Folder,Persistent Line 499  class ZSQLExtendFolder(Folder,Persistent
         self._getOb(index_name).setIndex(index)          self._getOb(index_name).setIndex(index)
                   
     def getIndex(self,index_name):      def getIndex(self,index_name):
         """getIndex"""          """getIndex from index_name
           return an indexObject with index_name
           """
           
         founds=self.ZopeFind(self,obj_ids=[index_name])          founds=self.ZopeFind(self,obj_ids=[index_name])
                   
         return founds[0][1].getIndex()          return founds[0][1].getIndex()
           
                           
     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 URLquote(self,txt):      def URLquote(self,txt):
         """urlquote"""          """urlquote
           @param txt: text der urlgequoted werden soll.
           """
         return urllib.quote(txt)          return urllib.quote(txt)
           
       
       def createIdSet(self, resultset, idField=None):
           """returns a (frozen)set of IDs from a SQL-resultset (using idField) or a list (if idField=None)"""
           logging.debug("createidset for idfield %s"%idField)
           if idField is None:
               return frozenset(resultset)
           else:
               idlist = [r[idField] for r in resultset]
               return frozenset(idlist)
           
       def opIdSet(self, a, b, op):
           """operate on sets a and b"""
           logging.debug("opidset with op %s"%op)
           if (op == 'intersect'):
               return a.intersection(b)
           elif (op == 'union'):
               return a.union(b)
           elif (op == 'diff'):
               return a.difference(b)
       
       
     def searchRel(self,relStatement,statement,wherePart,classes):      def searchRel(self,relStatement,statement,wherePart,classes):
         """suche relative haufigkeiten"""          """suche relative haufigkeiten (experimental)"""
         ret={}          ret={}
         allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))          allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))
                   
Line 237  class ZSQLExtendFolder(Folder,Persistent Line 546  class ZSQLExtendFolder(Folder,Persistent
         return (ret,allRecords)          return (ret,allRecords)
                                       
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content_html Aufruf, notwendig fuer Kompatibiliaet bei gemeinsamem Einsatz mich ECHO-Produkt"""
                   
         try:          try:
             obj=getattr(self,"ZSQLBibliography_template")              obj=getattr(self,"ZSQLBibliography_template")
Line 250  class ZSQLExtendFolder(Folder,Persistent Line 559  class ZSQLExtendFolder(Folder,Persistent
   
                   
     def getWeight(self):      def getWeight(self):
         """getLabe"""          """getWeight, gewicht notwendig fuer Kompatibiliaet bei gemeinsamem Einsatz mich ECHO-Produkt"""
         try:          try:
             return self.weight              return self.weight
         except:          except:
             return ""              return ""
   
     def getLabel(self):      def getLabel(self):
         """getLabel"""          """getLabel notwendig fuer Kompatibiliaet bei gemeinsamem Einsatz mich ECHO-Produkt"""
         try:          try:
             return self.label              return self.label
         except:          except:
             return ""              return ""
     
     def getTitle(self):  
         """getTitle"""  
         try:  
             return self.title  
         except:  
             return ""  
   
   
     def getDescription(self):      def getDescription(self):
         """getDescription"""          """getDEscription: notwendig fuer Kompatibiliaet bei gemeinsamem Einsatz mich ECHO-Produkt"""
         try:          try:
             return self.description              return self.description
         except:          except:
Line 288  class ZSQLExtendFolder(Folder,Persistent Line 589  class ZSQLExtendFolder(Folder,Persistent
         return pt()          return pt()
   
   
     def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):      def changeZSQLExtend(self,label,description,weight=0,connection_id=None,autocommit=None,REQUEST=None,):
         """change it"""          """change the Konfiguration"""
         self.connection_id=connection_id          self.connection_id=connection_id
         self.weight=weight          self.weight=weight
         self.label=label          self.label=label
         self.description=description          self.description=description
           self.autocommit = (autocommit == "on")
                   
         if REQUEST is not None:          if REQUEST is not None:
             return self.manage_main(self, REQUEST)              return self.manage_main(self, REQUEST)
   
     def formatAscii(self,str,url=None):      def formatAscii(self,str,url=None):
         """ersetze ascii umbrueche durch <br>"""          """ersetze ascii umbrueche durch <br>
         #url=None          @param str: string der Formatiert werden soll.
           @param url:  (optional) default ist "None", sonderfall erzeugt einen Link aus String mit unterliegender url
           """
           #logging.debug("formatascii str=%s url=%s"%(repr(str),repr(url)))
                   
         if not str:          if not str:
             return ""              return ""
Line 318  class ZSQLExtendFolder(Folder,Persistent Line 623  class ZSQLExtendFolder(Folder,Persistent
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)                  retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
             str=retStr              str=retStr
         if str:          if str:
             return re.sub(r"[\n]","<br/>",str)              retStr = re.sub(r"[\n]","<br/>",str)
               #logging.debug("formatascii out=%s"%(repr(retStr)))
               return retStr
         else:          else:
             return ""              return ""
                   
Line 360  class ZSQLExtendFolder(Folder,Persistent Line 667  class ZSQLExtendFolder(Folder,Persistent
         """oinly for demo"""          """oinly for demo"""
         return os.path.splitext(path)[0]+".jpg"          return os.path.splitext(path)[0]+".jpg"
                   
     def ZSQLisEmpty(self,field):      def ZSQLisEmpty(self,str):
         """Teste ob Treffer leer"""          """Teste ob String leer bzw. none ist.
           """
         #print "field",field          #print "field",field
         if not field:          if not str:
             return 1              return 1
         if field=="":          if str.strip()=="":
             return 1              return 1
         return 0          return 0
   
       def ZSQLMultiSearch(self,_table,_searchField,_value,_idField,_additionalStatement="",_select=None,_subselectAddition="",_storename=None):
           """
           Durchsucht in einer Tabelle "table" die Spalte "searchfield" nach dem allen Vorkommnissen 
           von Worten in value und gibt alle Werte mit gleichem id field zurueck, d.h. es wird die "und" suche ueber mehrere Eintrsege in einer
           Tabelle mit gleichem idField werd realisiert, 
           z.B. fuer simplesearch ueber mehrere Felder
           @param _table: Tabelle, die durchsucht werden soll.
           @param _searchField: Feld, das durchsucht wird
           @param _value: String der gesucht werden soll, gesucht wird nach allen Worten des Strings, die durch " "-getrennt sind.
           @param _idField: Feld mit id fuer die identifikation gleicher Eintraege
           @param _additionalStatement: (optional) Zusaetzliches SQL Statement, dass zwischen dem ersten "select from" und dem ersten "where" eingegefuegt wird.
           @param _subselectAddition: (optiona) Zusaetliche SQL Statement die hinter das select statement der subselects eingefuegt werde.
           @param _select: (optional) Alternativer Wert fuer den ersten SELECT Aufruf.
           @param _storename: (optional) Name fuer die Zwischenspeicherung von Werten in der Session
           """
           if _storename:
               """store"""
           else:
               _storename="foundCount"
               
           queries=[]
           #baue jede einzelne abfrage
           splitted=_value.split(" ")
           if not _select:
               _select=_idField
               
           query="select %s from  %s %s where lower(%s) like '%%%s%%'"%(_select,_table,_additionalStatement,_searchField,splitted[0].lower())
           
           if len(splitted)>1: # mehr als ein Wort
               query+=" and %s in"%_idField # dann einschraenken 
               for v in splitted[1:]:
                   queries.append("select %s from  %s %s where lower(%s) like '%%%s%%'"%(_idField,_table,_subselectAddition,_searchField,v.lower()))
                   
           
               intersect=" intersect ".join(queries) # nun baue sie zusammen
               query+="(%s)"%intersect
           
           
           logging.info("ZSQLSimple: %s"%query)
           retT=self.ZSQLSimpleSearch(query)
           logging.info("ZSQLSimple: %s"%retT)
           
           #das Ergebis enthaelt unter u.U. eine id mehrfach, dieses wir jetzt vereinheitlicht.
           
           retFinalT={}
           for x in retT:
               split=_idField.split(".")
               if len(split)>1:
                   f=split[1]
               else:
                   f=_idField
                   
               retFinalT[getattr(x,f)]=x
           
           ret=list(retFinalT.values())
           
           
           #aus Kompatibilaetsgruenen mit ZSQLSearch / ZSQLInlineSeach  noch einzelne Felder in der SESSION belegen.
           if not self.REQUEST.SESSION.has_key(_storename):
                   self.REQUEST.SESSION[_storename]={}
           
           self.REQUEST.SESSION[_storename]['searchFieldsOnly']={}
           self.REQUEST.SESSION[_storename]['qs']=query
           return ret
       
     def ZSQLsearchOptions(self,fieldname=""):      def ZSQLsearchOptions(self,fieldname=""):
         """return HTML Fragment with search options"""          """return HTML Fragment with search options"""
                   
Line 381  class ZSQLExtendFolder(Folder,Persistent Line 754  class ZSQLExtendFolder(Folder,Persistent
         return ret          return ret
   
     def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):      def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
         """generate select options from a cr seperated list"""          """generate selection HTML Fragemnt from a cr seperated list
           @param fieldname: Wert fuer das "name"-Attribute der erzeugten input-Tags
           @param listField: "cr" (\n) getrennte Liste der Werte
           @param boxType: (optional) default ist "checkbox", moegliche Werte "checkbox" und "radio"
           @param checked: "cr" getrennt Liste von Werten aus listField, die als ausgewahlt markiert werden sollen.
           """
         fields=listField.split("\n")          fields=listField.split("\n")
         ret=""          ret=""
         for field in fields:          for field in fields:
Line 392  class ZSQLExtendFolder(Folder,Persistent Line 770  class ZSQLExtendFolder(Folder,Persistent
         return ret          return ret
   
     def ZSQLSelectionFromSearchList(self,fieldname,results,fieldnameResult,boxType="checkbox",checked=None):      def ZSQLSelectionFromSearchList(self,fieldname,results,fieldnameResult,boxType="checkbox",checked=None):
         """generate select options from a cr seperated list"""          """generate select options from  research-results Objekt
           generate selection HTML Fragemnt from a cr seperated list
           @param fieldname: Wert fuer das "name"-Attribute der erzeugten input-Tags
           @param results: result Object einer SQL-suche
           @param fieldNameResult: Feldname des Resultobjekts, das angezeigt werden soll. 
           @param boxType: (optional) default ist "checkbox", moegliche Werte "checkbox" und "radio"
           @param checked: "cr" getrennt Liste von Werten aus results.fieldNameResult, die als ausgewahlt markiert werden sollen.     
           """
   
         ret=""          ret=""
         if not results: return ""          if not results: return ""
Line 432  class ZSQLExtendFolder(Folder,Persistent Line 817  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):      def ZSQLOptionsFromSearchList(self,fieldname,
                                     results,fieldName,
                                     valueName=None,start=None, 
                                     multiple='',startValue=None,
                                     additionalSelect="",size=None,
                                     linelen=None,selected=None,
                                     clear=False):
         """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 440  class ZSQLExtendFolder(Folder,Persistent Line 831  class ZSQLExtendFolder(Folder,Persistent
         <option value=result.fieldName>result.fieldValue</option>          <option value=result.fieldName>result.fieldValue</option>
         erzeugt.          erzeugt.
                   
         @parameter fieldname: Name fuer name-wert im select-tag          @param fieldname: Name fuer name-wert im select-tag
         @results results: Resultobject einer SQL-suche          @param results: Resultobject einer SQL-suche
         @parameter fieldName: Name des Feldes, das als value in den option-tag geschrieben werden soll.          @param 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          @param 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          @param start: (optional) falls zusaetzliches option tag erzeugt werden soll, gibt start an was im option tag steht
         @startValue: gibt den entsprechenden Wert an.          @param startValue (optional): gibt den entsprechenden Wert an.
           @param selected (optional): Wert der ausgewaehlt sein soll.
           @param linelen: (optional) maximale laenge eines Eintrages 
                       der im Klappmenue noch angezeigt wird, laengeres wird abgeschnitten.
           @param addionalSaelect (optional): zusaetzlicher text fuer den select tag
           @param clear (optional): setze auf den startwert. 
         """          """
         if not valueName:          if not valueName:
             valueName=fieldName              valueName=fieldName
Line 462  class ZSQLExtendFolder(Folder,Persistent Line 858  class ZSQLExtendFolder(Folder,Persistent
             if not startValue:              if not startValue:
                     startValue=start                      startValue=start
                                                           
               if clear:
                   ret+="""<option selected value="%s" >%s</option>"""%(startValue,start)
               else:
             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 not linelen:              if linelen and fieldValue and (len(fieldValue) > string.atoi(linelen)):
                     ret+="""<option value="%s">%s</option>"""%(field,fieldValue)                  displayValue = fieldValue[:string.atoi(linelen)]
                 else:              else: 
                     mist = """%s"""%(fieldValue)                  displayValue = fieldValue
                     if len(mist) > string.atoi(linelen):                  
                         mist = mist[:string.atoi(linelen)]              if displayValue: #show only if value not none
                     ret+="""<option value="%s">%s</option>"""%(field,mist)                  if field == selected:
       
                       ret+="""<option value="%s" selected>%s</option>"""%(field,displayValue)
                   else:
                       ret+="""<option value="%s">%s</option>"""%(field,displayValue)
   
         ret+="""</select>"""          ret+="""</select>"""
         return ret          return ret
   
                           
     def ZSQLInlineSearchU(self,storename=None,**argv):      def ZSQLInlineSearchU(self,storename=None,args=None,**argv):
         """one element if exists"""          """one element if exists"""
         qs=[]          qs=[]
         if storename:          if storename:
Line 487  class ZSQLExtendFolder(Folder,Persistent Line 892  class ZSQLExtendFolder(Folder,Persistent
         else:          else:
             storename="foundCount"              storename="foundCount"
                           
           if args:
               argTmp=args
           else:
               argTmp=argv
           
   
         #print "INLINE:",argv          #print "INLINE:",argv
         for a in argv.keys():          for a in argTmp.keys():
             qs.append(a+"="+urllib.quote(str(argv[a])))              aFiltered=re.sub(r"^-","_",a) # beginning of a command should always be "_"
               qs.append(aFiltered+"="+urllib.quote(str(argTmp[a])))
         #return []            #return []  
         ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)          ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)
   
Line 500  class ZSQLExtendFolder(Folder,Persistent Line 910  class ZSQLExtendFolder(Folder,Persistent
         except:          except:
             return None              return None
                   
     def ZSQLInlineSearch(self,storename=None,**argv):  
         """inlinesearch"""  
                   
       def ZSQLSequentialSearch(self,_fieldlist,_searchTerm,storename=None,args=None,**argv):
           """get a list of tuples (fields,searchoptions,table) to search the searchTerm in, returns dictionary. """
           #print "do search with:",_fieldlist,_searchTerm,storename,args,argv
           ret={} 
           if args:
               argTmp=args
           else:
               argTmp=argv
   
           for field in _fieldlist:
   
               argTmp2=copy.deepcopy(argTmp)
               argTmp2[field[0]]=_searchTerm
               argTmp2['_op_'+field[0]]=field[1]
               argTmp2['_table']=field[2]
               
               ret[field[0]]=(self.ZSQLInlineSearch(storename=storename,args=argTmp2),field[3],field[4],field[5],field[6])
           
           return ret
       
       
       def ZSQLInlineSearch(self,storename=None,args=None,**argv):
           """inlinesearch"""
           #logging.debug("ZSQLInlineSearch args=%s argv=%s"%(args,argv))
         qs=[]          qs=[]
         if storename:          if storename:
             """store"""              """store"""
         else:          else:
             storename="foundCount"              storename="foundCount"
                           
           if args:
               argTmp=args
           else:
               argTmp=argv
           
   
         #print "INLINE:",argv          #print "INLINE:",argv
         for a in argv.keys():          for a in argTmp.keys():
               aFiltered=re.sub(r"^-","_",a) # beginning of a command should always be "_"
         
               if type(argTmp[a]) is ListType: # ein parameter zweimal
                       value=""
                       #TODO find a better solution, currently only the last non empty entry is used.
                       #for x in argTmp[a]:
                       #    if x:
                       #        value=x
                       # version: join with spaces (makes sense with checkbox and -op=all)
                       value = " ".join(argTmp[a])
               else:
             try:              try:
                 qs.append(a+"="+urllib.quote(str(argv[a])))                  value=str(argTmp[a])
             except:              except:
                 import urllib                  value=utf8ify(argTmp[a])
                 qs.append(a+"="+urllib.quote(str(argv[a])))                  
               qs.append(aFiltered+"="+urllib.quote(value))
               #logging.debug("InlineSearch:"+string.join(qs,","))
                                   
         #return []            #return []  
   
         return self.parseQueryString(string.join(qs,","),"_",storename=storename)          return self.parseQueryString(string.join(qs,","),"_",storename=storename)
   
     def ZSQLInlineSearch2(self,query):      def ZSQLInlineSearch2(self,query):
Line 535  class ZSQLExtendFolder(Folder,Persistent Line 985  class ZSQLExtendFolder(Folder,Persistent
         try:          try:
             self.getConnectionObj().manage_close_connection()              self.getConnectionObj().manage_close_connection()
         except:          except:
             zLOG.LOG("ZSQLResetConnection",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])              logger("ZSQLResetConnection",logging.ERROR, '%s %s'%sys.exc_info()[:2])
         try:          try:
             self.getConnectionObj().manage_open_connection()              self.getConnectionObj().manage_open_connection()
         except:          except:
             zLOG.LOG("ZSQLResetConnection",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])              logger("ZSQLResetConnection",logging.ERROR, '%s %s'%sys.exc_info()[:2])
   
     def ZSQLSimpleSearch(self,query=None,max_rows=1000000,debug=None):  
         """simple search"""  
   
       def ZSQLSimpleSearch(self,query=None,max_rows=1000000):
           """new simple search"""
           logging.debug("new ZSQLSimpleSearch %s"%query)
           # get Connection instance
           con = self.getConnectionObj()
           # call to get db object
           dbc = con()
           if getattr(self, 'autocommit', False):
               # force transaction isolation level (for psycopg2 0=autocommit)
               logging.debug("  old tilevel=%s"%dbc.tilevel)
               dbc.tilevel = 0
               # modified code from ZPsycopgDA.db without _register:
               c = dbc.getcursor()
               desc = ()
               r = []
               try:
                   try:
                       c.execute(query)
                       
                   except psycopg2.OperationalError:
                       #logging.exception("Operational error on connection, closing it.")
                       try:
                           # Only close our connection
                           dbc.putconn(True)
                       except:
                           #logging.debug("Something went wrong when we tried to close the pool", exc_info=True)
                           pass
   
                   if c.description is not None:
                       if max_rows:
                           r = c.fetchmany(max_rows)
                       else:
                           r = c.fetchall()
                       desc = c.description
                       
                   dbc.failures = 0
       
               except StandardError, err:
                   raise err
               
               res = (dbc.convert_description(desc), r)
               
           else:
               logging.debug("  no autocommit")
               # just use DA's query method
               res = dbc.query(query, max_rows=max_rows)
               
           # return result set as Result object with Brains
           return Results(res)
           
       def oldZSQLSimpleSearch(self,query=None,max_rows=1000000):
           """simple search"""
           logging.error("ZSQLSimpleSearch X %s"%query)
           #print query
         if not query:          if not query:
             query=self.query              query=self.query
           
         if debug:          
                 print "DEBUG: ZSQLSimpleSearch:", query  
         if (hasattr(self,"_v_searchSQL") and (self._v_searchSQL == None)) or (not hasattr(self,"_v_searchSQL")):          if (hasattr(self,"_v_searchSQL") and (self._v_searchSQL == None)) or (not hasattr(self,"_v_searchSQL")):
                           
             self._v_searchSQL=Shared.DC.ZRDB.DA.DA("_v_searchSQL","_v_searchSQL",self.getConnectionObj().getId(),"var","<dtml-var var>")              self._v_searchSQL=Shared.DC.ZRDB.DA.DA("_v_searchSQL","_v_searchSQL",self.getConnectionObj().getId(),"var","<dtml-var var>")
               #self._v_searchSQL=self.getConnectionObj()()
                           
             self._v_searchSQL.max_rows_=max_rows              self._v_searchSQL.max_rows_=max_rows
               #self._v_searchSQL.set_client_encoding('UNICODE')
             try:              try:
                 return self._v_searchSQL.__call__(var=query)                  logging.error("I am here")
                   t=self._v_searchSQL.__call__(var=query)
                   #t=self._v_searchSQL.query(query)
                   logging.error("I am here %s"%t)
                   return t
             except :              except :
                   logger("ZSQLSimpleSearch ERROR1",logging.ERROR, '%s %s'%sys.exc_info()[:2])
                 if sys.exc_info()[0]=="Database Error":                  if sys.exc_info()[0]=="Database Error":
                     try:                      try:
                         self.getConnectionObj().manage_open_connection()                          self.getConnectionObj().manage_open_connection()
                     except:                      except:
                         zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])                          logger("ZSQLSimpleSearch ERROR2",logging.ERROR, '%s %s'%sys.exc_info()[:2])
         else:          else:
             try:              try:
   
                 self._v_searchSQL.max_rows_=max_rows                  self._v_searchSQL.max_rows_=max_rows
                   #self._v_searchSQL.set_client_encoding('UNICODE')
                                   
                 return self._v_searchSQL.__call__(var=query)                  return self._v_searchSQL.__call__(var=query)
                   #return self._v_searchSQL.query(query)
             except :              except :
                   logger("ZSQLSimpleSearch ERROR2",logging.ERROR, '%s %s'%sys.exc_info()[:2])
                 if sys.exc_info()[0]=="Database Error":                  if sys.exc_info()[0]=="Database Error":
                     try:                      try:
                         self.getConnectionObj().manage_open_connection()                          self.getConnectionObj().manage_open_connection()
                     except:                      except:
                         zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])                          logger("ZSQLSimpleSearch",logging.ERROR, '%s %s'%sys.exc_info()[:2])
   
     def getConnectionObj(self):      def getConnectionObj(self):
         if hasattr(self,'connection_id'):          if hasattr(self,'connection_id'):
Line 609  class ZSQLExtendFolder(Folder,Persistent Line 1117  class ZSQLExtendFolder(Folder,Persistent
           
                   
                   
     def ZSQLAdd(self,format=None,RESPONSE=None,**argv):      def ZSQLAdd(self,format=None,RESPONSE=None,args=None,_useRequest=True,**argv):
         """Neuer Eintrag"""          """Neuer Eintrag"""
                           
           if args:
               argTmp=args
           else:
               argTmp=argv
   
         qs_temp=[]          qs_temp=[]
           
           if  _useRequest:
         for a in self.REQUEST.form.keys():          for a in self.REQUEST.form.keys():
             qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))              qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
   
         qs=string.join(qs_temp,",")          qs=string.join(qs_temp,",")
                   
         for field in argv.keys():          for field in argTmp.keys():
                    if field[0]=="_":                     if field[0]=="_":
                        fieldTmp="-"+field[1:]                         fieldTmp="-"+field[1:]
                    else:                     else:
                        fieldTmp=field                         fieldTmp=field
                                                 
                    qs+=",%s=%s"%(fieldTmp,argv[field])                     qs+=",%s=%s"%(fieldTmp,argTmp[field])
                   
                   
         addList={}          addList={}
         for q in qs.split(","):          for q in qs.split(","):
               if len(q.split("="))<2:
                   continue
             name=re.sub("r'+'"," ",q.split("=")[0].lower())              name=re.sub("r'+'"," ",q.split("=")[0].lower())
          
             value=q.split("=")[1]              value=q.split("=")[1]
             value=re.sub(r'\+'," ",value)              value=re.sub(r'\+'," ",value)
             value=urllib.unquote(value)               value=urllib.unquote(value) 
Line 659  class ZSQLExtendFolder(Folder,Persistent Line 1176  class ZSQLExtendFolder(Folder,Persistent
         else:          else:
             return True              return True
                   
     def ZSQLChange(self,format=None,RESPONSE=None,USE_FORM=None,**argv):      def ZSQLChange(self,format=None,RESPONSE=None,USE_FORM=None,args=None,**argv):
         """change entries"""          """change entries"""
         #qs=self.REQUEST['QUERY_STRING']          #qs=self.REQUEST['QUERY_STRING']
         # very bad hack          # very bad hack
Line 667  class ZSQLExtendFolder(Folder,Persistent Line 1184  class ZSQLExtendFolder(Folder,Persistent
         qs_temp=[]          qs_temp=[]
         if USE_FORM or RESPONSE:          if USE_FORM or RESPONSE:
             for a in self.REQUEST.form.keys():              for a in self.REQUEST.form.keys():
           
                 qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))                  qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
   
                   
           if args:
               arg_tmp=args
           else:
               arg_tmp=argv
                   
         for field in argv.keys():          for field in arg_tmp.keys():
                                   
                    if field[0]=="_":                     if field[0]=="_":
                        fieldTmp="-"+field[1:]                         fieldTmp="-"+field[1:]
                    else:                     else:
                        fieldTmp=field                         fieldTmp=field
                                                 
                    qs_temp.append("%s=%s"%(fieldTmp,argv[field]))                     qs_temp.append("%s=%s"%(fieldTmp,arg_tmp[field]))
                   
                   
         changeList=[]          changeList=[]
                   logging.info("ZSQLChange qs_temp: %s"%repr(qs_temp))
         for q in qs_temp:          for q in qs_temp:
                           
             name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))              name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
Line 694  class ZSQLExtendFolder(Folder,Persistent Line 1216  class ZSQLExtendFolder(Folder,Persistent
                     table=urllib.unquote(value)                      table=urllib.unquote(value)
             elif name=="-identify":              elif name=="-identify":
                 identify=urllib.unquote(value)                  identify=urllib.unquote(value)
                 identify=identify.split("=")[0]+"="+sql_quote(identify.split("=")[1])                  # old code did identify with lower() which doesn't work for oids
                   #identify="lower("+identify.split("=")[0]+")="+sql_quote(identify.split("=")[1].lower())
                   (k,v) = identify.split("=")
                   identify="%s=%s"%(k,sql_quote(v))
             elif name=="-format":              elif name=="-format":
                 format=urllib.unquote(value)                  format=urllib.unquote(value)
             elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):              #elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
               elif (not (name[0]=="-" or name[0]=="_")):
   
                   if value=="":
                           changeList.append("\""+name+"\"=null")
                   else:
                 changeList.append("\""+name+"\"="+sql_quote(urllib.unquote(value)))                  changeList.append("\""+name+"\"="+sql_quote(urllib.unquote(value)))
                                   
         changeString=string.join(changeList,",")          changeString=string.join(changeList,",")
   
         queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)          queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
           logger("ZSQLExtend",logging.INFO,"CHANGE: "+queryString)
   
         self.ZSQLSimpleSearch(queryString)          self.ZSQLSimpleSearch(queryString)
                   
Line 714  class ZSQLExtendFolder(Folder,Persistent Line 1244  class ZSQLExtendFolder(Folder,Persistent
             return True              return True
         
   
     def ZSQLFindIndexed(self,qs="",select="oid,*",storename=None,indexedFields=['data_line'],restrictField='id_text',**argv):      def ZSQLFindIndexed(self,tableList=[],qs="",select="oid,*",storename=None,indexedFields=['data_line'],restrictField='id_text',**argv):
         """find2"""          """find2"""
                   
         for index in self.ZopeFind(self,obj_ids=indexedFields):          for index in self.ZopeFind(self,obj_ids=indexedFields):
Line 737  class ZSQLExtendFolder(Folder,Persistent Line 1267  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):
             """"loesche leere elemente aus der liste"""              """loesche leere elemente aus der liste"""
             ret=[]              ret=[]
             for x in list:              for x in list:
                 splitted=x.split("=")                  splitted=x.split("=")
Line 760  class ZSQLExtendFolder(Folder,Persistent Line 1290  class ZSQLExtendFolder(Folder,Persistent
                    if field[0]=="_":                     if field[0]=="_":
                        fieldTmp="-"+field[1:]                         fieldTmp="-"+field[1:]
                    else:                     else:
                        fieldTmp=urllib.unqoute(field)                         fieldTmp=field
                                                 
                    qs+=",%s=%s"%(fieldTmp,argv[field])                     qs+=",%s=%s"%(fieldTmp,argv[field])
                                         
Line 789  class ZSQLExtendFolder(Folder,Persistent Line 1319  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"]
                   
Line 808  class ZSQLExtendFolder(Folder,Persistent Line 1341  class ZSQLExtendFolder(Folder,Persistent
     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)
           return """<a href="%s"> %s</a>"""%(str,linkText)
   
         if storename:   
             """store"""    
         else:  
             storename="foundCount"  
         qs=self.REQUEST.SESSION[storename]['qs']  
   
       def ZSQLNewSearchURL(self, storename="foundCount",url=None,args=None,**argv):
           """suche mit alten parametern bis auf die in argv getauschten"""
         if args:          if args:
             argv=args              argv=args
                           
           #get the old queries
           qs=self.REQUEST.SESSION[storename]['qs']
         querys=qs.split(",")          querys=qs.split(",")
           
           #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 "_"
               try:
                   queryList[arg]=urllib.unquote_plus(query.split("=")[1])
               except:
                   queryList[arg]=''   
                   
         argList=[]          argList=[]
         arg=""          arg=""
         queryList=[x.split("=")[0] for x in querys]          #gehe durch die zu aendernden Argumente
           
         for argTmp in argv.keys():          for argTmp in argv.keys():
               arg=argTmp[0:]# sicherstellen, dass der string auh kopiert wird
               if arg[0]=="_": arg="-"+arg[1:] # sicherstellen, dass an Anfang stets "_"            
                           
                           queryList[arg]=argv[argTmp]
             arg=argTmp[0:]  
             if arg[0]=="_":arg="-"+argTmp[1:] # aender _ in - als standard  
   
             if arg not in queryList: # noch nicht drin  
                 querys.append("%s=%s"%(arg,argv[argTmp]))  
             argList.append(arg)  
   
   
           
         newquery=[]  
         for query in querys:  
             queryArg=query.split("=")[0]  
             qarg=queryArg[0:]  
             if qarg[0]=="-":qarg="_"+queryArg[1:] # aender _ in - als standard  
               
             if  queryArg in argList:  
                 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 """<a href="%s"> %s</a>"""%(str,linkText)          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):  
         """analysieren den QueryString"""  
                   
       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"""
           logging.debug("parseQueryString qs=%s"%qs)
                   
         #setzte generische werte          #setzte generische werte
                   
Line 924  class ZSQLExtendFolder(Folder,Persistent Line 1418  class ZSQLExtendFolder(Folder,Persistent
         opfields={}          opfields={}
         lopfields={} #Verknuepfung bei mehrfachauswahl von einem feld          lopfields={} #Verknuepfung bei mehrfachauswahl von einem feld
         sortfields={} #order of sortfields          sortfields={} #order of sortfields
           diacritics={} #diacritische zeichen, falls "no", dann werden diese fuer das feld gefiltert.
         sortAllFields=None          sortAllFields=None
         skip=""          skip=""
         rangeStart=0          rangeStart=0
Line 931  class ZSQLExtendFolder(Folder,Persistent Line 1426  class ZSQLExtendFolder(Folder,Persistent
         searchFields={}          searchFields={}
         searchFieldsOnly={}          searchFieldsOnly={}
         queryTemplate=[]          queryTemplate=[]
           outerjoin=""
           debug=None
                   
         if not select:          if not select:
             select="oid,*"              select="oid,*"
Line 949  class ZSQLExtendFolder(Folder,Persistent Line 1446  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 966  class ZSQLExtendFolder(Folder,Persistent Line 1466  class ZSQLExtendFolder(Folder,Persistent
                     field=name[5:]                      field=name[5:]
                     lopfields[field]=lop                      lopfields[field]=lop
                                           
                   if name[0:11]==iCT+"diacritics":
                       field=name[12:]
                       diacritics[field]=value
                       
                 if name[0:10]==iCT+"sortorder":                  if name[0:10]==iCT+"sortorder":
                     #sort=value                      #sort=value
                                           
Line 983  class ZSQLExtendFolder(Folder,Persistent Line 1487  class ZSQLExtendFolder(Folder,Persistent
                           
                       
             name=re.sub("r'+'"," ",q.split("=")[0].lower())              name=re.sub("r'+'"," ",q.split("=")[0].lower())
              
             try:              try:
                 value=urllib.unquote(q.split("=",1)[1])                  value=urllib.unquote(q.split("=",1)[1])
               
             except:              except:
                 value=""                  value=""
                           
             punktsplit=name.split(".")   #sonderfall feld mit punkten(tabelle.suchFeld.ausgewaehltesFeld,feldinoriginal), d.h. suche in anderer tabelle:                                    punktsplit=name.split(".")   #sonderfall feld mit punkten(tabelle.suchFeld.ausgewaehltesFeld,feldinoriginal), d.h. suche in anderer tabelle:                      
                     
             #analysiere alle anderen faelle              #analysiere alle anderen faelle
               
               if diacritics.get(name,'yes')=='no':
                   """filter diacritische zeichen"""
                   value=unicodedata.normalize('NFKD', value.decode('utf-8')).encode('ASCII', 'ignore')
                   
             if name==iCT+"lop":              if name==iCT+"lop":
                 lop=value                  lop=value
             elif name==iCT+"table":              elif name==iCT+"table":
Line 1007  class ZSQLExtendFolder(Folder,Persistent Line 1518  class ZSQLExtendFolder(Folder,Persistent
                 skip="OFFSET "+str(value)                  skip="OFFSET "+str(value)
                 rangeStart=str(value)                  rangeStart=str(value)
             elif name==iCT+"join":              elif name==iCT+"join":
                   
                 whereList.append(value)                  whereList.append(value)
               elif name==iCT+"outerjoin":
                   
                   outerjoin=value
             elif name==iCT+"sort":              elif name==iCT+"sort":
                 sortstrs=[]                  sortstrs=[]
            
                 for word in value.split(','):                  for word in value.split(','):
                     wordstr=word.lstrip().rstrip()                      wordstr=word.lstrip().rstrip()
                     if sortAllFields:                      if sortAllFields:
Line 1031  class ZSQLExtendFolder(Folder,Persistent Line 1547  class ZSQLExtendFolder(Folder,Persistent
                 op=value                  op=value
   
   
               #sonderfall Name hat das Format: 
               #TABELLE.SUCHFELD_IN_DIESER_TABELLE.SELECT_FIELD.IDENTIFIER_IN_TABELLE_-table
               #i.e. erzeugt wird
               #das Statement 
               #WHERE IDENTIFIER_IN_TABELLE in (select * from SELECT_FIELD
               #where LOWER(SUCHFELD_IN_DIESER_TABELLE) something  value)
               #something is defined by _op_TABELLE.SUCHFELD_IN_DIESER_TABELLE.SELECT_FIELD.IDENTIFIER_IN_TABELLE
                           
             elif (not name[0]==iCT) and len(punktsplit)==4:              elif (not name[0]==iCT) and len(punktsplit)==4:
                   
                 if opfields.has_key(name):                  if opfields.has_key(name):
                     op=opfields[name]                      op=opfields[name]
                 else:                  else:
                     op="ct"                      op="ct"
   
                 namealt=name                  namealt=name
                 name="LOWER("+punktsplit[1]+")"                   name="LOWER("+punktsplit[1]+")" 
                   value=value.lower()
                 if op=="ct":                  if op=="ct":
                     tmp=(name+" LIKE "+sql_quote("%"+value+"%"))                      tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
                 elif op=="gt":                  elif op=="gt":
Line 1061  class ZSQLExtendFolder(Folder,Persistent Line 1586  class ZSQLExtendFolder(Folder,Persistent
   
                 elif op=="numerical":                  elif op=="numerical":
                     term=analyseIntSearch(value)                      term=analyseIntSearch(value)
                     tmp=(name+" "+term)                      tmp=(namealt+" "+term) # take namealt without LOWER
                 elif op=="grep":                  elif op=="grep":
                     tmp=(name+" ~* "+sql_quote(value))                      tmp=(name+" ~* "+sql_quote(value))
                 elif op=="one":                  elif op=="one":
Line 1073  class ZSQLExtendFolder(Folder,Persistent Line 1598  class ZSQLExtendFolder(Folder,Persistent
   
                 op="all"                  op="all"
   
                   if value!='': #lehre Werte werde nicht hinzugefuegt
                 searchTmp="""%s in (select %s from %s where %s)"""%(punktsplit[3],punktsplit[2],punktsplit[0],tmp)                  searchTmp="""%s in (select %s from %s where %s)"""%(punktsplit[3],punktsplit[2],punktsplit[0],tmp)
   
                 queryTemplate.append(searchTmp)                  queryTemplate.append(searchTmp)
Line 1082  class ZSQLExtendFolder(Folder,Persistent Line 1607  class ZSQLExtendFolder(Folder,Persistent
   
         #print "OP",op,name          #print "OP",op,name
                 value=value.lower()                  value=value.lower()
                   
                 tmp=""                  tmp=""
                 if opfields.has_key(name):                  if opfields.has_key(name):
                     op=opfields[name]                      op=opfields[name]
Line 1110  class ZSQLExtendFolder(Folder,Persistent Line 1636  class ZSQLExtendFolder(Folder,Persistent
   
                 elif op=="numerical":                  elif op=="numerical":
                     term=analyseIntSearch(value)                      term=analyseIntSearch(value)
                     tmp=(name+" "+term)                      tmp=(namealt+" "+term) # take namealt without LOWER
                 elif op=="grep":                  elif op=="grep":
                     tmp=(name+" ~* "+sql_quote(value))                      tmp=(name+" ~* "+sql_quote(value))
                 elif op=="one":                  elif op=="one":
Line 1122  class ZSQLExtendFolder(Folder,Persistent Line 1648  class ZSQLExtendFolder(Folder,Persistent
   
                 op="all"                  op="all"
   
                 if (not tableExt) or (namealt.split('.')[0]==tableExt):                  if (value!='') and ((not tableExt) or (namealt.split('.')[0]==tableExt)): #keine leeren werde und keine auschluss
                     if searchFields.has_key(namealt):                      if searchFields.has_key(namealt):
                         searchFields[namealt]+=lopfields.get(name,'OR')+" "+tmp                          searchFields[namealt]+=lopfields.get(name,'OR')+" "+tmp
                         searchFieldsOnly[namealt]+=lopfields.get(name,'OR')+" "+value                          searchFieldsOnly[namealt]+=lopfields.get(name,'OR')+" "+value
Line 1155  class ZSQLExtendFolder(Folder,Persistent Line 1681  class ZSQLExtendFolder(Folder,Persistent
                                   
         #print "QE",table          #print "QE",table
         #print (select,table,where,sort,maxstr,skip)          #print (select,table,where,sort,maxstr,skip)
         query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)          query="SELECT %s FROM %s %s %s %s %s %s"%(select,table,outerjoin,where,sort,maxstr,skip)
   
         if not nostore=="yes":          if not nostore=="yes":
                           
             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 1187  class ZSQLExtendFolder(Folder,Persistent Line 1713  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 1194  class ZSQLExtendFolder(Folder,Persistent Line 1721  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)
             self.REQUEST.SESSION[storename]['rangeSize']=limit              self.REQUEST.SESSION[storename]['rangeSize']=limit
             self.REQUEST.SESSION[storename]['searchFields']=searchFields              self.REQUEST.SESSION[storename]['searchFields']=searchFields
             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 1225  class ZSQLExtendFolder(Folder,Persistent Line 1758  class ZSQLExtendFolder(Folder,Persistent
     def ZSQLQuery(self,query,debug=None):      def ZSQLQuery(self,query,debug=None):
         """query"""          """query"""
         if debug:          if debug:
             zLOG.LOG("ZSQLQuery", zLOG.INFO, query)              logger("ZSQLQuery", logging.INFO, query)
                           
         return self.ZSQLSimpleSearch(query)          return self.ZSQLSimpleSearch(query)
   
Line 1253  class ZSQLExtendFolder(Folder,Persistent Line 1786  class ZSQLExtendFolder(Folder,Persistent
         self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")          self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
         self.REQUEST.SESSION['come_from_search']="yes"          self.REQUEST.SESSION['come_from_search']="yes"
                   
         return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))          return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile)+"?"+rq)
   
           
     def ZSQLint(self,string):      def ZSQLint(self,string):
Line 1287  class ZSQLExtendFolder(Folder,Persistent Line 1820  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 1385  class ZSQLExtendFolder(Folder,Persistent Line 1918  class ZSQLExtendFolder(Folder,Persistent
         return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)          return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)
   
   
           def pydev_settrace(self):
     def prevLink_old(self,html):          """do settrace to start debugging"""
         """prev link"""          import pydevd
         if self.REQUEST['QUERY_STRING']=="":          pydevd.settrace()
             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())
Line 1755  def manage_addZSQLBibliography(self, id, Line 2235  def manage_addZSQLBibliography(self, id,
   
           
   
       
Removed from v.1.80  
changed lines
  Added in v.1.143

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