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

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.64 and 1.113

version 1.64, 2005/10/10 15:34:50 version 1.113, 2007/04/19 20:47:00
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  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
   
Line 14  from Products.ZSQLMethods.SQL import SQL Line 13  from Products.ZSQLMethods.SQL import SQL
 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
   
   def getTextFromNode(nodename):
       """get the cdata content of a node"""
       if nodename is None:
           return ""
       nodelist=nodename.childNodes
       rc = ""
       for node in nodelist:
           if node.nodeType == node.TEXT_NODE:
              rc = rc + node.data
       return rc
   
 def analyseIntSearch(word):  def analyseIntSearch(word):
     #analyse integer searches      #analyse integer searches
Line 42  def sql_quote(v): Line 63  def sql_quote(v):
     quote_dict = {"\'": "''", "\\": "\\\\"}      quote_dict = {"\'": "''", "\\": "\\\\"}
     for dkey in quote_dict.keys():      for dkey in quote_dict.keys():
         if string.find(v, dkey) >= 0:          if string.find(v, dkey) >= 0:
             v=join(split(v,dkey),quote_dict[dkey])              v=string.join(string.split(v,dkey),quote_dict[dkey])
     return "'%s'" % v      return "'%s'" % v
   
 def showSQLConnectionIDs(self):  def showSQLConnectionIDs(self):
     return SQLConnectionIDs(self)      return SQLConnectionIDs(self)
   
   class Options:
       """options class"""
       
   class ZSQLIndex(SimpleItem):
       """index"""
       meta_type="ZSQLIndex"
       
       def __init__(self,index,id,table=''):
           self.index=[x for x in index]
           self.id=id
           self.table=table
           
       def setIndex(self,index):
           self.index=[x for x in index]
           
       def getIndex(self):
           return self.index
   
 class ZSQLExtendFolder(Folder,Persistent, Implicit):  class ZSQLExtendFolder(Folder,Persistent, Implicit):
     """Folder"""      """Folder"""
     meta_type="ZSQLExtendFolder"      meta_type="ZSQLExtendFolder"
   
       def ZSQLQuote(self,str):
           """quote str for sql"""
           return sql_quote(str)
       
       
       def normalizeField(self,table,fieldname, newFieldName=None,mode="alter", RESPONSE=None):
           """normalize a field"""
           import unicodedata
           
           if not newFieldName:
               newFieldName=fieldname+"_normal"
               
           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")
               
   
               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 in access format into the table
           @param table: name of the table the xml shall be imported into
           @param containerTagName: XML-Tag which describes a dataset
           @param data: data to be imported
           @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
           @param RESPONSE: (optional)
           '''
           from xml.dom.pulldom import parseString,parse
           
           logger("import xml",logging.INFO,"called")
           #fh=file("/tmp/fmpxml.xml")
           import bz2
           import base64
           
           ret=""
           if data:
             data=bz2.decompress(base64.decodestring(data))
           
             logger("import xml",logging.INFO,"received file")
             doc=parseString(data)
             logger("import xml",logging.INFO,"parsed file")
   
           elif filename:
             fh=file(filename)
             doc=parse(fh)
             logger("import xml",logging.INFO,"parsed file")
           while 1:
               node=doc.getEvent()
   
               if node is None:
                   break;
               else:
                   if node[1].nodeName.lower()==container.lower(): # make everything case insensitive
                       doc.expandNode(node[1])
                       
                       dataSet={}
                       for col in node[1].childNodes:
                           if col.nodeType is col.ELEMENT_NODE: 
                               data=col.nodeName
                               dataSet[data]=getTextFromNode(col)
   
                       update=False
                       
                       if identify:
   
                           field=dataSet[identify]
   
                           searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)
                           logger("import xml",logging.INFO,searchStr)
                           search=self.ZSQLSimpleSearch(searchStr)
                           if search:
                               update=True
                       
                       if update:
                           tmp=[]
                           for fieldName in dataSet.keys():
                               tmp.append("""%s = %s"""%(fieldName,self.ZSQLQuote(dataSet[fieldName])))
                           setStr=",".join(tmp)
   
                           field=dataSet[identify]
                     
                           queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)
                           logger("update xml",logging.INFO,queryStr)
                           self.ZSQLSimpleSearch(queryStr)
                           ret+="ud: %s \n"%field
                       else:
   
                          
                           fields=",".join(dataSet.keys())
                           values=",".join([""" %s """%self.ZSQLQuote(dataSet[x]) for x in dataSet.keys()])
                     
                           
                           queryStr="""INSERT INTO %s  (%s) VALUES (%s)"""%(table,fields,values)
                           self.ZSQLSimpleSearch(queryStr)
                           logger("update xml",logging.INFO,queryStr)
                           
                           
                           
             
           return ret
           
       
       def importXMLFile(self,table,containerTagName,fieldNames,data=None,identify=None,filename=None,RESPONSE=None):
           #TODO: finish importXMLFile
           '''
           Import XML file into the table
           @param table: name of the table the xml shall be imported into
           @param containerTagName: XML-Tag which describes a dataset
           @param file: xmlfile handle
           @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
           @param RESPONSE: (optional)
           '''
           ret=""
           from xml.dom.pulldom import parseString
   
           doc=parseString(file.read())
           while 1:
               node=doc.getEvent()
           
               if node is None:
                   break;
               else:
                   if node[1].nodeName==containerTagName:
                       doc.expandNode(node[1])
                       cols=node[1].getElementsByTagName('COL')
                       dataSet=[]
                       for col in cols:
                           data=col.getElementsByTagName('DATA')
                           dataSet.append(getTextFromNode(data[0]))
                       update=False
                       if identify:
   
                           nr=fieldNames.index(identify)
                           field=dataSet[nr]
   
                           searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)
                           logger("import xml",logging.INFO,searchStr)
                           search=self.ZSQLSimpleSearch(searchStr)
                           if search:
                               update=True
                       
                       if update:
                           tmp=[]
                           for fieldName in fieldNames:
                               tmp.append("""%s = %s"""%(fieldName,self.ZSQLQuote(dataSet[fieldNames.index(fieldName)])))
                           setStr=",".join(tmp)
                           nr=fieldNames.index(identify)
                           field=dataSet[nr]
                     
                           queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)
                           logger("update xml",logging.INFO,queryStr)
                           self.ZSQLSimpleSearch(queryStr)
                           ret+="ud: %s \n"%field
                       else:
   
                          
                           fields=",".join(fieldNames)
                           values=",".join([""" %s """%self.ZSQLQuote(x) for x in dataSet])
                     
                           
                           queryStr="""INSERT INTO %s  (%s) VALUES (%s)"""%(table,fields,values)
                           self.ZSQLSimpleSearch(queryStr)
                           logger("update xml",logging.INFO,queryStr)
                           ret+="ad: %s \n"%field
                           
                   elif node[1].nodeName=="METADATA":
                       fieldNames=[]
                       doc.expandNode(node[1])
                   
                       names=node[1].getElementsByTagName('FIELD')
   
                       for name in names:
                           fieldNames.append(name.getAttribute('NAME'))
                       
                       logger("update xml: 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)]
                    
                       for fieldName in fieldNames:
                           logger("update xml: fieldname",logging.INFO,repr(fieldName))                     
                           if fieldName not in columns:
                               qstr="""alter table %s add %s %s"""
                               self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
                               logger("update xml: fieldname add",logging.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
   
   
       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.
           @param dsn: database connection string
           @param table: name of the table the xml shall be imported into
           @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 RESPONSE: (optional)
           @param redirect_url: (optional) url for redirecting after the upload is done
           '''
           
           tfilehd,filename=tempfile.mkstemp()
           tfile=os.fdopen(tfilehd,'w')
           logging.error("import %s"%uploadfile)
           for c in uploadfile.read():
               tfile.write(c)
           tfile.close()  
           
           from importFMPXML import importFMPXML
           
           if not dsn:
               dsn=self.getConnectionObj().connection_string
               
           options=Options()
           options.dsn=dsn
           options.table=table
           options.filename=filename
           options.update_fields=update_fields
           options.id_field=id_field
           options.sync_mode=sync_mode
           options.replace_table=replace
           options.lc_names=True
       options.ascii_db=ascii_db
           importFMPXML(options)
           
           os.remove(filename)
           
           if RESPONSE and redirect_url:
               RESPONSE.redirect(redirect_url)
               
       def generateIndex(self,field,index_name,table,RESPONSE=None):
           """erzeuge index aus feld"""
           index={}
           founds=self.ZSQLSimpleSearch("""SELECT %s,oid FROM %s LIMIT 2000"""%(field,table))
   
           for found in founds:
               tmp=getattr(found,field,None)
               if tmp:
                   strings=tmp.split(" ")
                   for string in strings:
                       if index.get(string):
                           index[string].append(found.oid)
                       else:
                           index[string]=[found.oid]
                       RESPONSE.write(string+"\n")
               
           if not hasattr(self,index_name):
               obj=ZSQLIndex(index,index_name,table)
               self._setObject(index_name,obj)
                       
           self._getOb(index_name).setIndex(index)
           
       def getIndex(self,index_name):
           """getIndex"""
           founds=self.ZopeFind(self,obj_ids=[index_name])
           
           return founds[0][1].getIndex()
       
   
     def testneu(self):      def testneu(self):
         """test"""          """test"""
Line 64  class ZSQLExtendFolder(Folder,Persistent Line 491  class ZSQLExtendFolder(Folder,Persistent
     def URLquote(self,txt):      def URLquote(self,txt):
         """urlquote"""          """urlquote"""
         return urllib.quote(txt)          return urllib.quote(txt)
       
     def searchRel(self,relStatement,statement,wherePart,classes):      def searchRel(self,relStatement,statement,wherePart,classes):
         """suche relative haufigkeiten"""          """suche relative haufigkeiten"""
         ret={}          ret={}
Line 131  class ZSQLExtendFolder(Folder,Persistent Line 559  class ZSQLExtendFolder(Folder,Persistent
     def formatAscii(self,str,url=None):      def formatAscii(self,str,url=None):
         """ersetze ascii umbrueche durch <br>"""          """ersetze ascii umbrueche durch <br>"""
         #url=None          #url=None
           str=str.rstrip().lstrip()
           
         if url and str:          if url and str:
                           
             retStr=""              retStr=""
Line 189  class ZSQLExtendFolder(Folder,Persistent Line 619  class ZSQLExtendFolder(Folder,Persistent
         #print "field",field          #print "field",field
         if not field:          if not field:
             return 1              return 1
         if field=="":          if field.strip()=="":
             return 1              return 1
         return 0          return 0
   
       def ZSQLMultiSearch(self,_table,_searchField,_value,_idField,_additionalStatement="",_select=None,_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 zurŸck, d.h. es wird die "und" suche realisiert, 
           z.B. fŸr simplesearch ueber mehrere Felder
           """
           if _storename:
               """store"""
           else:
               _storename="foundCount"
               
           queries=[]
           #baue jede einzelne abfrage
           splitted=_value.split(" ")
           if not _select:
               _select=_idField
               
           queries.append("select %s from  %s %s where lower(%s) like '%%%s%%'"%(_select,_table,_additionalStatement,_searchField,splitted[0].lower()))
           
           if len(splitted)>1:
               for v in splitted[1:]:
                   queries.append("select %s from  %s where lower(%s) like '%%%s%%'"%(_idField,_table,_searchField,v.lower()))
                   
           q=" and %s in ("%_idField
           query=q.join(queries) # nun baue sie zusammen
           for i in range(len(queries)-1):
               query+=")" #noch die klammern schliessen
           
           
           if _additionalStatement:
               query=query+" "
           
           logging.info("ZSQLSimple: %s"%query)
           retT=self.ZSQLSimpleSearch(query)
           logging.info("ZSQLSimple: %s"%retT)
           
           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())
           
           
               
           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 231  class ZSQLExtendFolder(Folder,Persistent Line 718  class ZSQLExtendFolder(Folder,Persistent
         return ret          return ret
   
   
     def ZSQLOptionsFromCRList(self,fieldname,listField, multiple='',start=None,startValue=None,size=None):      def ZSQLOptionsFromCRList(self,fieldname,listField, multiple='',start=None,startValue=None,size=None,selected=None):
         """generate select oprions form a cr seperated list"""          """generate select oprions form a cr seperated list"""
         fields=listField.split("\n")          fields=listField.split("\n")
         if size:          if size:
Line 249  class ZSQLExtendFolder(Folder,Persistent Line 736  class ZSQLExtendFolder(Folder,Persistent
                                           
             ret+="""<option value="%s" >%s</option>"""%(startValue,start)              ret+="""<option value="%s" >%s</option>"""%(startValue,start)
         for field in fields:          for field in fields:
               if selected and (field in selected.split("\n")):
                    ret+="""<option selected value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
               else:
             ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))              ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
         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 261  class ZSQLExtendFolder(Folder,Persistent Line 757  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 279  class ZSQLExtendFolder(Folder,Persistent Line 780  class ZSQLExtendFolder(Folder,Persistent
         if start:          if start:
         if start==' ':          if start==' ':
         start=''          start=''
               
                 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:
             """store"""              """store"""
               storename=storename
         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 319  class ZSQLExtendFolder(Folder,Persistent Line 836  class ZSQLExtendFolder(Folder,Persistent
         except:          except:
             return None              return None
                   
     def ZSQLInlineSearch(self,storename=None,**argv):       
       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"""          """inlinesearch"""
                   
         qs=[]          qs=[]
Line 330  class ZSQLExtendFolder(Folder,Persistent Line 869  class ZSQLExtendFolder(Folder,Persistent
                           
           
   
           if args:
               argTmp=args
           else:
               argTmp=argv
   
   
         #print "INLINE:",argv          #print "INLINE:",argv
         for a in argv.keys():          for a in argTmp.keys():
             try:              aFiltered=re.sub(r"^-","_",a) # beginning of a command should always be "_"
                 qs.append(a+"="+urllib.quote(str(argv[a])))        
             except:              if type(argTmp[a]) is ListType: # ein parameter zweimal
                 import urllib                      value=""
                 qs.append(a+"="+urllib.quote(str(argv[a])))                      #TODO find a better solution, currently only the last non empty entry is used.
                       for x in argTmp[a]:
                           if x:
                               value=x
               else:
                  
                   value=str(argTmp[a])
               qs.append(aFiltered+"="+urllib.quote(value))
               
                                   
         #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):
         """inlinesearch"""          """inlinesearch"""
         qs=[]          qs=[]
                   
       
           
         #print "INLINE:",query          #print "INLINE:",query
         return self.ZSQLSimpleSearch(query)          return self.ZSQLSimpleSearch(query)
           
           
       def ZSQLResetConnection(self):
           """reset the connectione"""
           try:
               self.getConnectionObj().manage_close_connection()
           except:
               logger("ZSQLResetConnection",logging.ERROR, '%s %s'%sys.exc_info()[:2])
           try:
               self.getConnectionObj().manage_open_connection()
           except:
               logger("ZSQLResetConnection",logging.ERROR, '%s %s'%sys.exc_info()[:2])
   
     def ZSQLSimpleSearch(self,query=None,max_rows=1000000):      def ZSQLSimpleSearch(self,query=None,max_rows=1000000):
         """simple search"""          """simple search"""
           logging.error("ZSQLSimpleSearch X %s"%query)
           #print query
         if not query:          if not query:
             query=self.query              query=self.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.connection_id,"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.max_rows_=max_rows              self._v_searchSQL.max_rows_=max_rows
             try:              try:
                                   logging.error("I am here")
                 return self._v_searchSQL.__call__(var=query)                  t=self._v_searchSQL.__call__(var=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:
                         getattr(self,self.connection_id).manage_open_connection()                          self.getConnectionObj().manage_open_connection()
                     except: pass                      except:
                           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
                                   
                 return self._v_searchSQL.__call__(var=query)                  return self._v_searchSQL.__call__(var=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:
                         getattr(self,self.connection_id).manage_open_connection()                          self.getConnectionObj().manage_open_connection()
                     except: pass                      except:
                           logger("ZSQLSimpleSearch",logging.ERROR, '%s %s'%sys.exc_info()[:2])
   
       def getConnectionObj(self):
           if hasattr(self,'connection_id'):
               return getattr(self,self.connection_id)
          
                                           
     def ZSQLSimpleSearch2(self,query=None):      def ZSQLSimpleSearch2(self,query=None):
         """ returrn SQLSearch"""          """ returrn SQLSearch"""
         #print "hi",query         
         if not query:          if not query:
             query=self.query              query=self.query
         if getattr(self,'_v_search',None):          if getattr(self,'_v_search',None):
Line 406  class ZSQLExtendFolder(Folder,Persistent Line 984  class ZSQLExtendFolder(Folder,Persistent
           
                   
                   
     def ZSQLAdd(self):      def ZSQLAdd(self,format=None,RESPONSE=None,args=None,**argv):
         """Neuer Eintrag"""          """Neuer Eintrag"""
         qs=self.REQUEST['QUERY_STRING']              
       if args:
               argTmp=args
           else:
               argTmp=argv
   
           qs_temp=[]
       
           for a in self.REQUEST.form.keys():
               qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
   
           qs=string.join(qs_temp,",")
           
           for field in argTmp.keys():
                      if field[0]=="_":
                          fieldTmp="-"+field[1:]
                      else:
                          fieldTmp=field
                          
                      qs+=",%s=%s"%(fieldTmp,argTmp[field])
           
           
         addList={}          addList={}
         for q in qs.split("&"):          for q in qs.split(","):
             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)
Line 419  class ZSQLExtendFolder(Folder,Persistent Line 1018  class ZSQLExtendFolder(Folder,Persistent
                 table=urllib.unquote(value)                  table=urllib.unquote(value)
             elif name=="-format":              elif name=="-format":
                 format=urllib.unquote(value)                  format=urllib.unquote(value)
             elif (not name[0]=="-") and (not len(value)==0):              elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
                 addList[urllib.unquote(name)]=urllib.unquote(value)                  addList[urllib.unquote(name)]=urllib.unquote(value)
   
         keyList=[]          keyList=[]
Line 432  class ZSQLExtendFolder(Folder,Persistent Line 1031  class ZSQLExtendFolder(Folder,Persistent
         valueString=string.join(valueList,",")          valueString=string.join(valueList,",")
                   
         queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)          queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)
   
         self.ZSQLSimpleSearch(queryString)          self.ZSQLSimpleSearch(queryString)
         return self.REQUEST.RESPONSE.redirect(format)  
                   
     def ZSQLChange(self,format=None,RESPONSE=None,**argv):          if RESPONSE and format:
               return RESPONSE.redirect(format)
           else:
               return True
           
       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
                   
         qs_temp=[]          qs_temp=[]
               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])))
   
         qs=string.join(qs_temp,",")  
                   
         for field in argv.keys():          if args:
               arg_tmp=args
           else:
               arg_tmp=argv
               
           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+=",%s=%s"%(fieldTmp,argv[field])                     qs_temp.append("%s=%s"%(fieldTmp,arg_tmp[field]))
                   
                   
         changeList=[]          changeList=[]
         for q in qs.split(","):          logging.info("ZSQLChange qs_temp: %s"%repr(qs_temp))
             print q          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()))
             value="=".join(q.split("=")[1:])              value="=".join(q.split("=")[1:])
             value=re.sub(r'\+'," ",value)              value=re.sub(r'\+'," ",value)
Line 468  class ZSQLExtendFolder(Folder,Persistent Line 1079  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])                  identify="lower("+identify.split("=")[0]+")="+sql_quote(identify.split("=")[1].lower())
             elif name=="-format":              elif name=="-format":
                 format=urllib.unquote(value)                  format=urllib.unquote(value)
             elif (not 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 485  class ZSQLExtendFolder(Folder,Persistent Line 1104  class ZSQLExtendFolder(Folder,Persistent
             return True              return True
         
   
       def ZSQLFindIndexed(self,tableList=[],qs="",select="oid,*",storename=None,indexedFields=['data_line'],restrictField='id_text',**argv):
           """find2"""
           
           for index in self.ZopeFind(self,obj_ids=indexedFields):
               txt=argv.get(index[0],None)
               if txt:
                   oids=index[1].getIndex()[txt]
                   
           search1= self.ZSQLFind(qs=qs,select=select,storename=storename,tableExt=tableList[1],restrictField=restrictField,NoQuery='yes',NoLimit='yes',**argv)
        
           search2 = self.ZSQLFind(tableExt=tableList[0],qs=qs,select=select,storename=storename,restrictConnect=(tableList[0]+"."+restrictField,search1),**argv)
           return search2
       
     def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],restrictField='id_text',**argv):      def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],restrictField='id_text',**argv):
         """find2"""          """find2"""
   
Line 495  class ZSQLExtendFolder(Folder,Persistent Line 1127  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):
         """Find"""          """search in database"""
   
         def delEmpty(list):          def delEmpty(list):
               """"loesche leere elemente aus der liste"""
             ret=[]              ret=[]
             for x in list:              for x in list:
                 splitted=x.split("=")                  splitted=x.split("=")
Line 506  class ZSQLExtendFolder(Folder,Persistent Line 1139  class ZSQLExtendFolder(Folder,Persistent
                     ret.append(x)                      ret.append(x)
             return ret              return ret
   
   
   
         #self.REQUEST.SESSION['come_from_search']="no" # zuruecksetzen  
         if qs=="":          if qs=="":
                         #kein querystring ubergeben 
            if self.REQUEST['QUERY_STRING']:             if self.REQUEST['QUERY_STRING']:
                qs=self.REQUEST['QUERY_STRING']                 qs=self.REQUEST['QUERY_STRING']
   
                  
                qs=string.join(qs.split("&"),",")                 qs=string.join(qs.split("&"),",")
   
                for field in argv.keys():                 for field in argv.keys():
Line 546  class ZSQLExtendFolder(Folder,Persistent Line 1175  class ZSQLExtendFolder(Folder,Persistent
                           
                   
                   
         qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.          qs=re.sub("\\+"," ",qs)#TODO: Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.
   
         qs=string.join(delEmpty(qs.split(",")),",")          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 569  class ZSQLExtendFolder(Folder,Persistent Line 1201  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(",")
         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 "_"
               try:
                   queryList[arg]=query.split("=")[1]
               except:
                   queryList[arg]=''   
                           
             arg=argTmp[0:]          argList=[]
             if arg[0]=="_":arg="-"+argTmp[1:] # aender _ in - als standard          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 """<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):      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"""
                   
                   
           #setzte generische werte
           
         lop="AND" # standardsuche mit and          lop="AND" # standardsuche mit and
         max="ALL" #standard alle auswaehlen          max="ALL" #standard alle auswaehlen
         maxstr=""          maxstr=""
Line 683  class ZSQLExtendFolder(Folder,Persistent Line 1282  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
         limit=0          limit=0
         searchFields={}          searchFields={}
         searchFieldsOnly={}          searchFieldsOnly={}
           queryTemplate=[]
           outerjoin=""
           debug=None
           
         if not select:          if not select:
             select="oid,*"              select="oid,*"
         #print "Q",nostore,qs  
         #check for op   
   
   
   
                   
           #check for op 
     splitted=qs.split(",")      splitted=qs.split(",")
   
         if tableExt:          if tableExt:
             table=tableExt              table=tableExt
   
         if restrictField:          if restrictField:
                     select=restrictField                      select=restrictField
                           
           
           #erster durchgang suche operatoren    
         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 724  class ZSQLExtendFolder(Folder,Persistent Line 1330  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 735  class ZSQLExtendFolder(Folder,Persistent Line 1345  class ZSQLExtendFolder(Folder,Persistent
                     else:                      else:
                         sortfields[field]=value                          sortfields[field]=value
                                           
                     #print "HI",op,field          #zweiter durchgang analysiere felder
     #print opfieldsa  
         #now analyse the querystring  
          
         for q in qs.split(","):          for q in qs.split(","):
                 
                           
             #try:  
   
             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=""
                           
             #value=sql_quote(value)              punktsplit=name.split(".")   #sonderfall feld mit punkten(tabelle.suchFeld.ausgewaehltesFeld,feldinoriginal), d.h. suche in anderer tabelle:                      
            
               #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
Line 769  class ZSQLExtendFolder(Folder,Persistent Line 1382  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 793  class ZSQLExtendFolder(Folder,Persistent Line 1411  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:
                   
                   if opfields.has_key(name):
                       op=opfields[name]
                   else:
                       op="ct"
                   namealt=name
                   name="LOWER("+punktsplit[1]+")" 
                   value=value.lower()
                   if op=="ct":
                       tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
                   elif op=="gt":
                       tmp=(name+">"+sql_quote(value))
                   elif op=="lt":
                       tmp=(name+"<"+sql_quote(value))
                   elif op=="eq":
                       tmp=(name+"="+sql_quote(value))
                   elif op=="bw":
                       tmp=(name+" LIKE "+sql_quote(value+"%"))
                   elif op=="ew":
                       tmp=(name+" LIKE "+sql_quote("%"+value))
                   elif op=="all":
                       tmps=[]
                       for word in value.split(" "):
                           tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
                           
                       tmp=string.join(tmps,' AND ')
   
                   elif op=="numerical":
                       term=analyseIntSearch(value)
                       tmp=(name+" "+term)
                   elif op=="grep":
                       tmp=(name+" ~* "+sql_quote(value))
                   elif op=="one":
                       tmps=[]
                       for word in value.split(" "):
                           tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
                           
                       tmp=string.join(tmps,' OR ')
   
                   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)
   
                       queryTemplate.append(searchTmp)
   
             elif (not name[0]==iCT) and (not len(value)==0):              elif (not name[0]==iCT) and (not len(value)==0):
   
         #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 838  class ZSQLExtendFolder(Folder,Persistent Line 1511  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 848  class ZSQLExtendFolder(Folder,Persistent Line 1521  class ZSQLExtendFolder(Folder,Persistent
   
   
         whereList=["("+searchFields[x]+")" for x in searchFields.keys()]          whereList=["("+searchFields[x]+")" for x in searchFields.keys()]
           whereList+=queryTemplate
                   
         if len(whereList)>0:          if len(whereList)>0:
             if filter:              if filter:
Line 870  class ZSQLExtendFolder(Folder,Persistent Line 1544  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)
                           
             #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']              #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
Line 901  class ZSQLExtendFolder(Folder,Persistent Line 1576  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 908  class ZSQLExtendFolder(Folder,Persistent Line 1584  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 935  class ZSQLExtendFolder(Folder,Persistent Line 1618  class ZSQLExtendFolder(Folder,Persistent
         else:          else:
             return value              return value
                   
     def ZSQLQuery(self,query):      def ZSQLQuery(self,query,debug=None):
         """query"""          """query"""
           if debug:
               logger("ZSQLQuery", logging.INFO, query)
   
         return self.ZSQLSimpleSearch(query)          return self.ZSQLSimpleSearch(query)
   
           
     def ZSQLSearch(self):      def ZSQLSearch(self):
         """To be done"""          """To be done"""
         rq=self.REQUEST['QUERY_STRING']  
   
         querys=rq.split("&")  
           
                   
         formatfile=self.REQUEST['URL1'] #generisch redirect zur gleichen url          formatfile=self.REQUEST['URL1'] #generisch redirect zur gleichen url
                   
         for querytemp in querys:          #zerlege querystring in key value paare
             query=querytemp.split("=")          #TODO: check if this is really necessary, use argv**
               
               
   
           rq=self.REQUEST['QUERY_STRING']
           querys=rq.split("&")
           for querytemp in querys: #zerg
               query=querytemp.split("=")
                           
             try:              try:
                 if query[0].lower()=="-format":                  if query[0].lower()=="-format":
                     formatfile=query[1]                      formatfile=query[1]
             except:              except:
                 """nothing"""                  pass
   
                   
         #print formatfile  
           
                   
           #sichern
         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 1003  class ZSQLExtendFolder(Folder,Persistent Line 1683  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 1102  class ZSQLExtendFolder(Folder,Persistent Line 1782  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())
   
Line 1341  class ZSQLBibliography(Folder,ZSQLExtend Line 1964  class ZSQLBibliography(Folder,ZSQLExtend
         else:          else:
             return ""              return ""
           
     def getMetaDataXML2(self):      def getXML2(self):
         """crate index meta"""          """crate index meta"""
   
         fn=os.path.splitext(self.REQUEST['fn'])[0]+"."          fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
Line 1405  class ZSQLBibliography(Folder,ZSQLExtend Line 2028  class ZSQLBibliography(Folder,ZSQLExtend
         host_port = self.REQUEST['SERVER_PORT']          host_port = self.REQUEST['SERVER_PORT']
         fix_host = None          fix_host = None
         if http_host and http_host.rfind(host_port) == -1:          if http_host and http_host.rfind(host_port) == -1:
             print "HTTP_HOST needs fixing!"              #print "HTTP_HOST needs fixing!"
             fix_host = http_host + ":" + host_port              fix_host = http_host + ":" + host_port
                   
         ret="""<?xml version="1.0" ?>          ret="""<?xml version="1.0" ?>
Removed from v.1.64  
changed lines
  Added in v.1.113

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