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

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.70 and 1.100

version 1.70, 2005/10/24 23:50:53 version 1.100, 2007/01/31 14:32:52
Line 14  from Products.ZSQLMethods.SQL import SQL Line 14  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 logging
   
   #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 48  def sql_quote(v): Line 70  def sql_quote(v):
 def showSQLConnectionIDs(self):  def showSQLConnectionIDs(self):
     return SQLConnectionIDs(self)      return SQLConnectionIDs(self)
   
   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.LOG("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'))
                   logging.LOG("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
           
           logging.LOG("import xml",logging.INFO,"called")
           #fh=file("/tmp/fmpxml.xml")
           import bz2
           import base64
           
           ret=""
           if data:
             data=bz2.decompress(base64.decodestring(data))
           
             logging.LOG("import xml",logging.INFO,"received file")
             doc=parseString(data)
             logging.LOG("import xml",logging.INFO,"parsed file")
   
           elif filename:
             fh=file(filename)
             doc=parse(fh)
             logging.LOG("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)
                           logging.LOG("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)
                           logging.LOG("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)
                           logging.LOG("update xml",logging.INFO,queryStr)
                           
                           
                           
             
           return ret
           
       
       def importXMLFile(self,table,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)
           '''
           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)
                           logging.LOG("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)
                           logging.LOG("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)
                           logging.LOG("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'))
                       
                       logging.LOG("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:
                           logging.LOG("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'))
                               logging.LOG("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,data=None,filename=None,update_fields=None,id_field=None,sync_mode=False,RESPONSE=None):
           '''
           Import FileMaker XML file (FMPXMLRESULT format) into the table.
           @param table: name of the table the xml shall be imported into
           @param data: xml data as bz2 string
           @param filename: xmlfile filename
           @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)
           '''
           from xml.dom.pulldom import parseString,parse
           import transaction
   
           ret = ""
   
           if data:
               data=bz2.decompress(base64.decodestring(data))
               zLOG.LOG("fmpxml",zLOG.INFO,"received file")
               doc=parseString(data)
               zLOG.LOG("fmpxml",zLOG.INFO,"parsed file")
   
           elif filename:
               fh=file(filename)
               zLOG.LOG("fmpxml",zLOG.INFO,"reading file")
               doc=parse(fh)
               zLOG.LOG("fmpxml",zLOG.INFO,"parsed file")
   
           dbIDs = {}
           rowcnt = 0
           
           if id_field is not None:
               # prepare a list of ids for sync mode
               qstr="select %s from %s"%(id_field,table)
               for id in self.ZSQLSimpleSearch(qstr):
                   # value 0: not updated
                   dbIDs[id[0]] = 0;
                   rowcnt += 1
                   
               zLOG.LOG("fmpxml",zLOG.INFO,"%d entries in DB to sync"%rowcnt)
           
           fieldNames = []
           rowcnt = 0
           id_val = ''
           
           while 1:
               node=doc.getEvent()
           
               if node is None:
                   break;
               
               # METADATA tag defines number and names of fields in FMPXMLRESULT
               if node[1].nodeName == 'METADATA':
                   doc.expandNode(node[1])
               
                   names=node[1].getElementsByTagName('FIELD')
   
                   for name in names:
                       fn = name.getAttribute('NAME')
                       fieldNames.append(fn)
                   
                   if update_fields is None:
                       # update all fields
                       update_fields = fieldNames
                   
                   zLOG.LOG("fmpxml fieldnames:",zLOG.INFO,repr(fieldNames))
                   # get list of fields in db table
                   qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s'"""
                   columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]
                   
                   # adjust db table to fields in XML and fieldlist
                   for fieldName in fieldNames:
                       zLOG.LOG("fmpxml fieldname:",zLOG.INFO,repr(fieldName))                     
                       if (fieldName not in columns) and (fieldName in update_fields):
                           qstr="""alter table %s add %s %s"""
                           self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
                           zLOG.LOG("fmpxml add field:",zLOG.INFO,qstr%(table,fieldName,'text'))
                           
               # ROW tags (in RESULTSET tag) hold data
               elif node[1].nodeName == 'ROW':
                   rowcnt += 1
                   
                   doc.expandNode(node[1])
                   cols=node[1].getElementsByTagName('COL')
                   dataSet={}
                   i = 0
                   # populate with data
                   for col in cols:
                       data=col.getElementsByTagName('DATA')
                       dataSet[fieldNames[i]] = getTextFromNode(data[0])
                       i += 1
                       
                   update=False
                   
                   # synchronize by id_field
                   if id_field:
                       id_val=dataSet[id_field]
                       if id_val in dbIDs:
                           dbIDs[id_val] += 1
                           update=True
                   
                   if update:
                       # update existing row (by id_field)
                       setvals=[]
                       for fieldName in update_fields:
                           setvals.append("%s = %s"%(fieldName,self.ZSQLQuote(dataSet[fieldName])))
                       setStr=string.join(setvals, ',')
                       id_val=dataSet[id_field]
                       qstr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,id_field,id_val)
                       #zLOG.LOG("fmpxml update:",zLOG.INFO,queryStr)
                       self.ZSQLSimpleSearch(qstr)
                       ret+="up: %s \n"%id_val
                   else:
                       # create new row
                       fields=string.join(update_fields, ',')
                       values=string.join([" %s "%self.ZSQLQuote(dataSet[x]) for x in update_fields], ',')
                       qstr="""INSERT INTO %s (%s) VALUES (%s)"""%(table,fields,values)
                       self.ZSQLSimpleSearch(qstr)
                       #zLOG.LOG("fmpxml: insert",zLOG.INFO,queryStr)
                       ret+="ad: %s \n"%dataSet.get(id_field, rowcnt)
   
                   #zLOG.LOG("fmpxml row:",zLOG.INFO,"%d (%s)"%(rowcnt,id_val))
                   if (rowcnt % 10) == 0:
                       zLOG.LOG("fmpxml row:",zLOG.INFO,"%d (%s)"%(rowcnt,id_val))
                       transaction.commit()
   
           transaction.commit()
           if sync_mode:
               # delete unmatched entries in db
               for id in dbIDs.keys():
                   # find all not-updated fields
                   if dbIDs[id] == 0:
                       zLOG.LOG("fmpxml delete:",zLOG.INFO,id)
                       qstr = "DELETE FROM %s WHERE %s = '%s'"
                       self.ZSQLSimpleSearch(qstr%(table,id_field,id))
                       
                   elif dbIDs[id] > 1:
                       zLOG.LOG("fmpxml sync:",zLOG.INFO,"id used more than once?"+id)
               
               transaction.commit()
               
           return ret        
           
       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 589  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 657  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 256  class ZSQLExtendFolder(Folder,Persistent Line 784  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):
         """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 282  class ZSQLExtendFolder(Folder,Persistent Line 810  class ZSQLExtendFolder(Folder,Persistent
         if start:          if start:
         if start==' ':          if start==' ':
         start=''          start=''
               
                 if not startValue:                  if not startValue:
                     startValue=start                      startValue=start
                                           
Line 290  class ZSQLExtendFolder(Folder,Persistent Line 819  class ZSQLExtendFolder(Folder,Persistent
             field=getattr(result,fieldName)              field=getattr(result,fieldName)
             fieldValue=getattr(result,valueName)              fieldValue=getattr(result,valueName)
             if fieldValue:              if fieldValue:
   
                 if not linelen:                  if not linelen:
   
                       
                       if field == selected:
   
                           ret+="""<option value="%s" selected>%s</option>"""%(field,fieldValue)
                       else:
                     ret+="""<option value="%s">%s</option>"""%(field,fieldValue)                      ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
   
                 else:                  else:
                     mist = """%s"""%(fieldValue)                      mist = """%s"""%(fieldValue)
                     if len(mist) > string.atoi(linelen):                      if len(mist) > string.atoi(linelen):
Line 301  class ZSQLExtendFolder(Folder,Persistent Line 838  class ZSQLExtendFolder(Folder,Persistent
         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 322  class ZSQLExtendFolder(Folder,Persistent Line 865  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 333  class ZSQLExtendFolder(Folder,Persistent Line 898  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])))          qs.append(aFiltered+"="+urllib.quote(str(argTmp[a])))
             except:              
                 import urllib  
                 qs.append(a+"="+urllib.quote(str(argv[a])))  
                                   
         #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 352  class ZSQLExtendFolder(Folder,Persistent Line 922  class ZSQLExtendFolder(Folder,Persistent
         return self.ZSQLSimpleSearch(query)          return self.ZSQLSimpleSearch(query)
           
           
       def ZSQLResetConnection(self):
           """reset the connectione"""
           try:
               self.getConnectionObj().manage_close_connection()
           except:
               logging.LOG("ZSQLResetConnection",logging.ERROR, '%s %s'%sys.exc_info()[:2])
           try:
               self.getConnectionObj().manage_open_connection()
           except:
               logging.LOG("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"""
                   
           #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.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.max_rows_=max_rows              self._v_searchSQL.max_rows_=max_rows
             try:              try:
                   
                 return self._v_searchSQL.__call__(var=query)                  return self._v_searchSQL.__call__(var=query)
             except :              except :
   
                 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])                          logging.LOG("ZSQLSimpleSearch",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 :
   
                 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])                          logging.LOG("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 415  class ZSQLExtendFolder(Folder,Persistent Line 1000  class ZSQLExtendFolder(Folder,Persistent
           
                   
                   
     def ZSQLAdd(self,format=None,RESPONSE=None,**argv):      def ZSQLAdd(self,format=None,RESPONSE=None,args=None,**argv):
         """Neuer Eintrag"""          """Neuer Eintrag"""
                           
       if args:
               argTmp=args
           else:
               argTmp=argv
   
         qs_temp=[]          qs_temp=[]
           
         for a in self.REQUEST.form.keys():          for a in self.REQUEST.form.keys():
Line 425  class ZSQLExtendFolder(Folder,Persistent Line 1015  class ZSQLExtendFolder(Folder,Persistent
   
         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={}
Line 473  class ZSQLExtendFolder(Folder,Persistent Line 1063  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])))
   
                   
Line 503  class ZSQLExtendFolder(Folder,Persistent Line 1094  class ZSQLExtendFolder(Folder,Persistent
                 identify=identify.split("=")[0]+"="+sql_quote(identify.split("=")[1])                  identify=identify.split("=")[0]+"="+sql_quote(identify.split("=")[1])
             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)
           logging.LOG("ZSQLExtend",logging.INFO,"CHANGE: "+queryString)
                   
         self.ZSQLSimpleSearch(queryString)          self.ZSQLSimpleSearch(queryString)
                   
Line 518  class ZSQLExtendFolder(Folder,Persistent Line 1116  class ZSQLExtendFolder(Folder,Persistent
             return True              return True
         
   
       def ZSQLFindIndexed(self,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 529  class ZSQLExtendFolder(Folder,Persistent Line 1140  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=None,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 539  class ZSQLExtendFolder(Folder,Persistent Line 1151  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 579  class ZSQLExtendFolder(Folder,Persistent Line 1187  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(",")),",")
   
Line 658  class ZSQLExtendFolder(Folder,Persistent Line 1266  class ZSQLExtendFolder(Folder,Persistent
           
     def ZSQLNewSearch(self,linkText,storename=None,url=None,args=None,**argv):      def ZSQLNewSearch(self,linkText,storename=None,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)
           
   
       def ZSQLNewSearchURL(self, storename=None,url=None,args=None,**argv):
           """suche mit alten parametern bis auf die in argv getauschten"""
   
         if storename:           if storename: 
             """store"""                """store"""  
Line 701  class ZSQLExtendFolder(Folder,Persistent Line 1315  class ZSQLExtendFolder(Folder,Persistent
         else:          else:
             str="ZSQLSearch?"+"&".join(newquery)              str="ZSQLSearch?"+"&".join(newquery)
                   
         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=None,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 716  class ZSQLExtendFolder(Folder,Persistent Line 1332  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=[]
           
         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())
Line 757  class ZSQLExtendFolder(Folder,Persistent Line 1375  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 768  class ZSQLExtendFolder(Folder,Persistent Line 1390  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:
Line 783  class ZSQLExtendFolder(Folder,Persistent Line 1401  class ZSQLExtendFolder(Folder,Persistent
             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 826  class ZSQLExtendFolder(Folder,Persistent Line 1449  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"
   
   
                   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):
   
Line 881  class ZSQLExtendFolder(Folder,Persistent Line 1557  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 911  class ZSQLExtendFolder(Folder,Persistent Line 1588  class ZSQLExtendFolder(Folder,Persistent
         #print "IAMHERE again:", query          #print "IAMHERE again:", query
   
         if storename and (not NoQuery):          if storename and (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 947  class ZSQLExtendFolder(Folder,Persistent Line 1625  class ZSQLExtendFolder(Folder,Persistent
                 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 not NoQuery:          if not NoQuery:
Line 971  class ZSQLExtendFolder(Folder,Persistent Line 1650  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)              logging.LOG("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"
                   
Line 1440  class ZSQLBibliography(Folder,ZSQLExtend Line 2114  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.70  
changed lines
  Added in v.1.100

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