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

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.34 and 1.105

version 1.34, 2004/09/27 18:51:57 version 1.105, 2007/02/22 13:23:20
Line 1 Line 1
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from Globals import Persistent  
 from Acquisition import Implicit  from Acquisition import Implicit
 from Globals import DTMLFile  from Globals import DTMLFile,package_home,Persistent
 import urllib  import urllib
 import re  import re
 import string  import string
 from pyPgSQL import libpq  import sys
   #from pyPgSQL import libpq
 from AccessControl import getSecurityManager  from AccessControl import getSecurityManager
 import os.path  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   
 from Products.ZSQLMethods.SQL import SQLConnectionIDs  from Products.ZSQLMethods.SQL import SQLConnectionIDs
   from xml.sax.saxutils import escape
   from types import *
 import Shared.DC.ZRDB.DA  import Shared.DC.ZRDB.DA
   import logging
   import os.path
   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):
       #analyse integer searches
   
       splitted=word.split("-")
   
       if len(splitted)==1:
           return "="+splitted[0]
       
       if splitted[0]=="":
           return "< "+splitted[1]
   
       if splitted[1]=='':
           return "> "+splitted[0]
       else:
           return "BETWEEN "+splitted[0]+" AND "+splitted[1]
   
           
   
   def sql_quote(v):
       # quote dictionary
       quote_dict = {"\'": "''", "\\": "\\\\"}
       for dkey in quote_dict.keys():
           if string.find(v, dkey) >= 0:
               v=string.join(string.split(v,dkey),quote_dict[dkey])
       return "'%s'" % 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.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,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)
                           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,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))
               logger("fmpxml",logging.INFO,"received file")
               doc=parseString(data)
               logger("fmpxml",logging.INFO,"parsed file")
   
           elif filename:
               fh=file(filename)
               logger("fmpxml",logging.INFO,"reading file")
               doc=parse(fh)
               logger("fmpxml",logging.INFO,"parsed file")
   
           dbIDs = {}
           rowcnt = 0
           
           if id_field is not None:
               # prepare a list of ids for sync mode
               qstr="select %s from %s"%(id_field,table)
               for id in self.ZSQLSimpleSearch(qstr):
                   # value 0: not updated
                   dbIDs[id[0]] = 0;
                   rowcnt += 1
                   
               logger("fmpxml",logging.INFO,"%d entries in DB to sync"%rowcnt)
           
           fieldNames = []
           rowcnt = 0
           id_val = ''
           
           while 1:
               node=doc.getEvent()
           
               if node is None:
                   break;
               
               # METADATA tag defines number and names of fields in FMPXMLRESULT
               if node[1].nodeName == 'METADATA':
                   doc.expandNode(node[1])
               
                   names=node[1].getElementsByTagName('FIELD')
   
                   for name in names:
                       fn = name.getAttribute('NAME')
                       fieldNames.append(fn)
                   
                   if update_fields is None:
                       # update all fields
                       update_fields = fieldNames
                   
                   logger("fmpxml fieldnames:",logging.INFO,repr(fieldNames))
                   # get list of fields in db table
                   qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s'"""
                   columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]
                   
                   # adjust db table to fields in XML and fieldlist
                   for fieldName in fieldNames:
                       logger("fmpxml fieldname:",logging.INFO,repr(fieldName))                     
                       if (fieldName not in columns) and (fieldName in update_fields):
                           qstr="""alter table %s add %s %s"""
                           self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
                           logger("fmpxml add field:",logging.INFO,qstr%(table,fieldName,'text'))
                           
               # ROW tags (in RESULTSET tag) hold data
               elif node[1].nodeName == 'ROW':
                   rowcnt += 1
                   
                   doc.expandNode(node[1])
                   cols=node[1].getElementsByTagName('COL')
                   dataSet={}
                   i = 0
                   # populate with data
                   for col in cols:
                       data=col.getElementsByTagName('DATA')
                       dataSet[fieldNames[i]] = getTextFromNode(data[0])
                       i += 1
                       
                   update=False
                   
                   # 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)
                       #logger("fmpxml update:",logging.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)
                       #logger("fmpxml: insert",logging.INFO,queryStr)
                       ret+="ad: %s \n"%dataSet.get(id_field, rowcnt)
   
                   #logger("fmpxml row:",logging.INFO,"%d (%s)"%(rowcnt,id_val))
                   if (rowcnt % 10) == 0:
                       logger("fmpxml row:",logging.INFO,"%d (%s)"%(rowcnt,id_val))
                       transaction.commit()
   
           transaction.commit()
           if sync_mode:
               # delete unmatched entries in db
               for id in dbIDs.keys():
                   # find all not-updated fields
                   if dbIDs[id] == 0:
                       logger("fmpxml delete:",logging.INFO,id)
                       qstr = "DELETE FROM %s WHERE %s = '%s'"
                       self.ZSQLSimpleSearch(qstr%(table,id_field,id))
                       
                   elif dbIDs[id] > 1:
                       logger("fmpxml sync:",logging.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"""
         relStatement="""period like '%s%%'"""          relStatement="""period like '%s%%'"""
Line 28  class ZSQLExtendFolder(Folder,Persistent Line 586  class ZSQLExtendFolder(Folder,Persistent
         classes=['Uruk III','Uruk IV']          classes=['Uruk III','Uruk IV']
         return self.searchRel(relStatement,statement,wherePart,classes)          return self.searchRel(relStatement,statement,wherePart,classes)
           
       def URLquote(self,txt):
           """urlquote"""
           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={}
         allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))          allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))
         print statement + " where "+wherePart          
         for oneclass in classes:          for oneclass in classes:
             ret[oneclass]=len(self.ZSQLSimpleSearch(statement + " where ("+wherePart+") and "+ relStatement%oneclass))              ret[oneclass]=len(self.ZSQLSimpleSearch(statement + " where ("+wherePart+") and "+ relStatement%oneclass))
             print statement + " where ("+wherePart+") and "+ relStatement%oneclass          
         return (ret,allRecords)          return (ret,allRecords)
                                       
     def content_html(self):      def content_html(self):
Line 45  class ZSQLExtendFolder(Folder,Persistent Line 607  class ZSQLExtendFolder(Folder,Persistent
             obj=getattr(self,"ZSQLBibliography_template")              obj=getattr(self,"ZSQLBibliography_template")
             return obj()              return obj()
         except:          except:
             pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt',content_type='text/htm').__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ZSQLBibliography_template_standard.zpt'),content_type='text/html').__of__(self)
             pt.content_type="text/html"              pt.content_type="text/html"
                           
             return pt()              return pt()
Line 78  class ZSQLExtendFolder(Folder,Persistent Line 640  class ZSQLExtendFolder(Folder,Persistent
   
     def changeZSQLExtendForm(self):      def changeZSQLExtendForm(self):
         """change folder config"""          """change folder config"""
         pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLExtendForm.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeZSQLExtendForm.zpt')).__of__(self)
         return pt()          return pt()
   
   
Line 95  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 153  class ZSQLExtendFolder(Folder,Persistent Line 717  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
   
Line 169  class ZSQLExtendFolder(Folder,Persistent Line 733  class ZSQLExtendFolder(Folder,Persistent
         return ret          return ret
   
     def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):      def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
         """generate select oprions form a cr seperated list"""          """generate select options from a cr seperated list"""
         fields=listField.split("\n")          fields=listField.split("\n")
         ret=""          ret=""
         for field in fields:          for field in fields:
Line 179  class ZSQLExtendFolder(Folder,Persistent Line 743  class ZSQLExtendFolder(Folder,Persistent
                 ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))                  ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
         return ret          return ret
   
       def ZSQLSelectionFromSearchList(self,fieldname,results,fieldnameResult,boxType="checkbox",checked=None):
           """generate select options from a cr seperated list"""
   
           ret=""
           if not results: return ""
           
           for result in results:
               field=getattr(result,fieldnameResult)
               if field:
                   if checked and (getattr(result,fieldnameResult) in checked.split("\n")):
                       ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
                   else:
                       ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
           return ret
   
   
     def ZSQLOptionsFromCRList(self,fieldname,listField, multiple=''):      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:
               ret="""<select name="%s" %s size="%s" >
               """%(fieldname,multiple,size)
   
           else:
         ret="""<select name="%s" %s>          ret="""<select name="%s" %s>
             """%(fieldname,multiple)              """%(fieldname,multiple)
           if start:
               if start==' ':
                   start=''
                   if not startValue:
                       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):      def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None,additionalSelect="",size=None,linelen=None,selected=None):
         """generate select oprions form a search list seperated list"""          """generate select options form a search list
           es wird
           <select name=fieldname mutiple>
           <option value=startValue>start</option>
           <option value=result.fieldName>result.fieldValue</option>
           erzeugt.
           
           @parameter fieldname: Name fuer name-wert im select-tag
           @results results: Resultobject einer SQL-suche
           @parameter fieldName: Name des Feldes, das als value in den option-tag geschrieben werden soll.
           @parameter valueName: (optional) Name des Feldes, dass als im option-tag ausgegeben wird, default wert ist valueName=fieldName
           @start: (optional) falls zusaetzliches option tag erzeugt werden soll, gibt start an was im option tag steht
           @startValue: gibt den entsprechenden Wert an.
           @linelen: (optional) maximale laenge eines Eintrages 
                       der im Klappmenue noch angezeigt wird, laengeres wird abgeschnitten.
           """
         if not valueName:          if not valueName:
             valueName=fieldName              valueName=fieldName
                       if size:
         ret="""<select name="%s" %s>              ret="""<select name="%s" %s size="%s" %s>
             """%(fieldname,multiple)              """%(fieldname,multiple,size,additionalSelect)
           else:
               ret="""<select name="%s" %s %s>
               """%(fieldname,multiple,additionalSelect)
         if start:          if start:
         if start==' ':          if start==' ':
         start=''          start=''
               
                 if not startValue:                  if not startValue:
                     startValue=start                      startValue=start
                                           
Line 207  class ZSQLExtendFolder(Folder,Persistent Line 820  class ZSQLExtendFolder(Folder,Persistent
         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 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:
                       mist = """%s"""%(fieldValue)
                       if len(mist) > string.atoi(linelen):
                           mist = mist[:string.atoi(linelen)]
                       ret+="""<option value="%s">%s</option>"""%(field,mist)
         ret+="""</select>"""          ret+="""</select>"""
         return ret          return ret
   
                           
     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 233  class ZSQLExtendFolder(Folder,Persistent Line 868  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=[]
         if storename:          if storename:
             """store"""              """store"""
Line 243  class ZSQLExtendFolder(Folder,Persistent Line 901  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():
             qs.append(a+"="+urllib.quote(str(argv[a])))              aFiltered=re.sub(r"^-","_",a) # beginning of a command should always be "_"
         
               if type(argTmp[a]) is ListType: # ein parameter zweimal
                       value=""
                       #TODO find a better solution, currently only the last non empty entry is used.
                       for x in argTmp[a]:
                           if x:
                               value=x
               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 ZSQLSimpleSearch(self,query=None):      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):
           """simple search"""
       
           #print query
           if not query:
               query=self.query
           
           
           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.max_rows_=max_rows
               try:
                   return self._v_searchSQL.__call__(var=query)
               except :
   
                   if sys.exc_info()[0]=="Database Error":
                       try:
                           self.getConnectionObj().manage_open_connection()
                       except:
                           logger("ZSQLSimpleSearch",logging.ERROR, '%s %s'%sys.exc_info()[:2])
           else:
               try:
   
                   self._v_searchSQL.max_rows_=max_rows
                   
                   return self._v_searchSQL.__call__(var=query)
               except :
   
                   if sys.exc_info()[0]=="Database Error":
                       try:
                           self.getConnectionObj().manage_open_connection()
                       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):
         """ returrn SQLSearch"""          """ returrn SQLSearch"""
          
         if not query:          if not query:
             query=self.query              query=self.query
           if getattr(self,'_v_search',None):
                         
         if self.search.meta_type=="Z SQL Method":              return self._v_search(var=query)
           
           if hasattr(self,'search') and (self.search.meta_type=="Z SQL Method"):
               self._v_search=self.search
             return self.search(var=query)              return self.search(var=query)
         else:          else:
             if self.aq_parent.aq_parent.search.meta_type=="Z SQL Method":              if hasattr(self.aq_parent.aq_parent,'search') and (self.aq_parent.aq_parent.search.meta_type=="Z SQL Method"):
                   self._v_search=self.aq_parent.aq_parent.search
                 return self.aq_parent.aq_parent.search(var=query)                  return self.aq_parent.aq_parent.search(var=query)
             else:              else:
                   search=self.ZopeFind(self,obj_metatypes=["Z SQL Method"],search_sub=1)
                   if search:
                       self._v_search=search[0][1]
                       return search[0][1](var=query)
                   else:
                 return []                  return []
           
                   
                   
     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 287  class ZSQLExtendFolder(Folder,Persistent Line 1046  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=[]
         valueList=[]          valueList=[]
         for x in addList.keys():          for x in addList.keys():
             keyList.append("\""+x+"\"")              keyList.append("\""+x+"\"")
             valueList.append(libpq.PgQuoteString(addList[x]))              valueList.append(sql_quote(addList[x]))
   
         keyString=string.join(keyList,",")          keyString=string.join(keyList,",")
         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,**argv):          if RESPONSE and format:
         """Ändern von Einträgen"""              return RESPONSE.redirect(format)
           else:
               return True
           
       def ZSQLChange(self,format=None,RESPONSE=None,USE_FORM=None,args=None,**argv):
           """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,"&")  
   
           if args:
               arg_tmp=args
           else:
               arg_tmp=argv
               
           for field in arg_tmp.keys():
                   
                      if field[0]=="_":
                          fieldTmp="-"+field[1:]
                      else:
                          fieldTmp=field
                          
                      qs_temp.append("%s=%s"%(fieldTmp,arg_tmp[field]))
           
         #print "CHANGE QS",self.REQUEST  
         #return self.REQUEST  
         changeList=[]  
         for q in qs.split("&"):  
             name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))  
             value=q.split("=")[1]  
             value=re.sub(r'\+'," ",value)  
         value=urllib.unquote(value)  
         if name=="-table":  
                 table=urllib.unquote(value)  
             elif name=="-identify":  
                 identify=urllib.unquote(value)  
                 identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])  
             elif name=="-format":  
                 format=urllib.unquote(value)  
             elif (not name[0]=="-") and (not len(value)==0):  
                 changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))  
         changeString=string.join(changeList,",")  
         queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)  
         self.ZSQLSimpleSearch(queryString)  
         return self.REQUEST.RESPONSE.redirect(format)  
   
     def ZSQLChange_old(self):  
         """Ändern von Einträgen"""  
         qs=self.REQUEST['QUERY_STRING']  
         #print "CHANGE QS",self.REQUEST  
         #return self.REQUEST  
         changeList=[]          changeList=[]
         for q in qs.split("&"):          logging.info("ZSQLChange qs_temp: %s"%repr(qs_temp))
           for q in qs_temp:
          
             name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))              name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
             value=q.split("=")[1]              value="=".join(q.split("=")[1:])
             value=re.sub(r'\+'," ",value)              value=re.sub(r'\+'," ",value)
         value=urllib.unquote(value)          value=urllib.unquote(value)
            
         if name=="-table":          if name=="-table":
                 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]+"="+libpq.PgQuoteString(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]=="-") and (not len(value)==0):              #elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
                 changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))              elif (not (name[0]=="-" or name[0]=="_")):
   
           if value=="":
                       changeList.append("\""+name+"\"=null")
           else:
                       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)
         return self.REQUEST.RESPONSE.redirect(format)  
   
   
           if RESPONSE and format:
               return RESPONSE.redirect(format)
           else:
               return True
      
   
     def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],**argv):      def ZSQLFindIndexed(self,qs="",select="oid,*",storename=None,indexedFields=['data_line'],restrictField='id_text',**argv):
         """find2"""          """find2"""
         #search1= self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt='cdli_translit',restrictField='id_text',NoQuery='yes',NoLimit='yes',**argv)  
   
           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='cdli_cat',qs="",select="oid,*",storename=None,restrictConnect=('cdli_cat.id_text',search1),**argv)          search2 = self.ZSQLFind(tableExt=tableList[0],qs=qs,select=select,storename=storename,restrictConnect=(tableList[0]+"."+restrictField,search1),**argv)
           return search2
   
         search1= self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt='cdli_cat',restrictField='id_text',NoQuery='yes',NoLimit='yes',**argv)      def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],restrictField='id_text',**argv):
           """find2"""
   
         search2 = self.ZSQLFind(tableExt='cdli_translit',qs="",select="oid,*",storename=None,restrictConnect=('cdli_translit.id_text',search1),**argv)          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          return search2
           
         #return self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,**argv)  
           
     def ZSQLFind(self,qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,**argv):      
         """Find"""      def ZSQLFind(self,qs="",select="oid,*",storename="foundCount",tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,**argv):
           """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 389  class ZSQLExtendFolder(Folder,Persistent Line 1167  class ZSQLExtendFolder(Folder,Persistent
                     ret.append(x)                      ret.append(x)
             return ret              return ret
                   
         #self.REQUEST.SESSION['come_from_search']="no" # zurücksetzen  
         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():
                      if field[0]=="_":
                          fieldTmp="-"+field[1:]
                      else:
                          fieldTmp=field
                                         
                    qs+=",-%s=%s"%(field,argv[field])                     qs+=",%s=%s"%(fieldTmp,argv[field])
                                         
            else:             else:
                                 
                qs=self.REQUEST.SESSION.get('query','')                 qs=self.REQUEST.SESSION.get('query','')
                                 
                for field in argv.keys():                 for field in argv.keys():
                    #print field                     if field[0]=="_":
                    qs+=",-%s=%s"%(field,argv[field])                         fieldTmp="-"+field[1:]
                      else:
                          fieldTmp=field
                      
                      qs+=",%s=%s"%(fieldTmp,argv[field])
   
            
                                 
         else:          else:
             self.REQUEST['QUERY_STRING']=qs              self.REQUEST['QUERY_STRING']=qs
Line 417  class ZSQLExtendFolder(Folder,Persistent Line 1203  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"""          #store query for further usage
         else:          #TODO: erste der beiden ist ueberfluessig
             storename="foundCount"          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)
Line 437  class ZSQLExtendFolder(Folder,Persistent Line 1227  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=="":          return self.REQUEST.SESSION[storename]['count']
                           
 ##             if self.REQUEST['QUERY_STRING']:      def ZSQLRangeStart(self,storename="foundCount"):
                           
 ##                 qs=self.REQUEST['QUERY_STRING']          return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
 ##                 qs=string.join(qs.split("&"),",")  
 ##             else:  
                           
 ##                 qs=self.REQUEST.SESSION['query']      def ZSQLRangeSize(self,storename="foundCount"):
 ##         else:  
 ##             qs=string.join(qs.split("&"),",")  
   
           return self.REQUEST.SESSION[storename]['rangeSize']
   
 ##         temp= self.parseQueryString(qs,"-",select=select,storemax="yes",nostore="yes")      def ZSQLRangeEnd(self,storename="foundCount"):
         if storename:  
             """store"""  
         else:  
             storename="foundCount"  
                   
         return self.REQUEST.SESSION[storename]['count']          return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))
   
     def ZSQLRangeStart(self,storename=None):      def ZSQLNewQuery(self,linkText,storename="foundCount",**argv):
           """suche neu"""
           return self.ZSQLNewSearch(linkText,storename,url=self.REQUEST['URL'],args=argv)
                   
         if storename:      def ZSQLNewSearch(self,linkText,storename="foundCount",url=None,args=None,**argv):
             """store"""          """suche mit alten parametern bis auf die in argv getauschten"""
         else:          str = self.ZSQLNewSearchURL(storename, url, args, **argv)
             storename="foundCount"          return """<a href="%s"> %s</a>"""%(str,linkText)
                   
         return int(self.REQUEST.SESSION[storename]['rangeStart'])+1  
           
     def ZSQLRangeSize(self,storename=None):      def ZSQLNewSearchURL(self, storename="foundCount",url=None,args=None,**argv):
           """suche mit alten parametern bis auf die in argv getauschten"""
           if args:
               argv=args
                   
         if storename:          #get the old queries
             """store"""          qs=self.REQUEST.SESSION[storename]['qs']
         else:          querys=qs.split(",")
             storename="foundCount"  
                           
         return self.REQUEST.SESSION[storename]['rangeSize']          #which arguments are in the old query string
   
     def ZSQLRangeEnd(self,storename=None):          queryList={}
           for query in querys:
               arg=query.split("=")[0]
               if arg[0]=="_": arg="-"+arg[1:] # sicherstellen, dass an Anfang stets "_"
               queryList[arg]=query.split("=")[1]
                   
         if storename:  
             """store"""          argList=[]
           arg=""
           
           
           
           #gehe durch die zu aendernden Argumente
           for argTmp in argv.keys():
               
               arg=argTmp[0:]# sicherstellen, dass der string auh kopiert wird
               if arg[0]=="_": arg="-"+arg[1:] # sicherstellen, dass an Anfang stets "_"            
   
               queryList[arg]=argv[argTmp]
   
           if url:
               str=url+"?"+urllib.urlencode(queryList)
         else:          else:
             storename="foundCount"              str="ZSQLSearch?"+urllib.urlencode(queryList)
                   
         return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))          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"""
         #print "NO",nostore         
          
           #setzte generische werte
           
         lop="AND" # standardsuche mit and          lop="AND" # standardsuche mit and
         max="ALL" #standard alle auswählen          max="ALL" #standard alle auswaehlen
         maxstr=""          maxstr=""
         whereList=[]          whereList=[]
         sort=""          sort=""
         op="bw"          op="bw"
         opfields={}          opfields={}
         lopfields={} #Verknüpfung 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
         skip=""          skip=""
         rangeStart=0          rangeStart=0
         limit=0          limit=0
         searchFields={}          searchFields={}
         searchFieldsOnly={}          searchFieldsOnly={}
           queryTemplate=[]
           outerjoin=""
           
         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 536  class ZSQLExtendFolder(Folder,Persistent Line 1350  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
   
                     field=name[11:]                      field=name[11:]
                     sortfields[field]=sort                      sortAllFields=None
                       #no field selected
                       if field=="":
                           sortAllFields=value
                       else:
                           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=libpq.PgQuoteString(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 575  class ZSQLExtendFolder(Folder,Persistent Line 1402  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:
                           order=sortAllFields
                       else:
                     order=sortfields.get(wordstr,'ASC')                      order=sortfields.get(wordstr,'ASC')
                           
                       if not (wordstr == ""):
                     sortstrs.append(wordstr+" "+order)                      sortstrs.append(wordstr+" "+order)
                 if len(sortstrs)>0:                  if len(sortstrs)>0:
                     sort="ORDER BY "+string.join(sortstrs,',')                      sort="ORDER BY "+string.join(sortstrs,',')
                                   
                       
             elif name==iCT+"token":              elif name==iCT+"token":
                 if not nostore=="yes":                  if not nostore=="yes":
                     self.REQUEST.SESSION['token']=value                      self.REQUEST.SESSION['token']=value
Line 593  class ZSQLExtendFolder(Folder,Persistent Line 1431  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):
                                   
         #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 606  class ZSQLExtendFolder(Folder,Persistent Line 1498  class ZSQLExtendFolder(Folder,Persistent
                 namealt=name                  namealt=name
                 name="LOWER("+name+")"                      name="LOWER("+name+")"    
                 if op=="ct":                  if op=="ct":
                     tmp=(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))                      tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
                 elif op=="gt":                  elif op=="gt":
                     tmp=(name+">"+libpq.PgQuoteString(value))                      tmp=(name+">"+sql_quote(value))
                 elif op=="lt":                  elif op=="lt":
                     tmp=(name+"<"+libpq.PgQuoteString(value))                      tmp=(name+"<"+sql_quote(value))
                 elif op=="eq":                  elif op=="eq":
                     tmp=(name+"="+libpq.PgQuoteString(value))                      tmp=(name+"="+sql_quote(value))
                 elif op=="bw":                  elif op=="bw":
                     tmp=(name+" LIKE "+libpq.PgQuoteString(value+"%"))                      tmp=(name+" LIKE "+sql_quote(value+"%"))
                 elif op=="ew":                  elif op=="ew":
                     tmp=(name+" LIKE "+libpq.PgQuoteString("%"+value))                      tmp=(name+" LIKE "+sql_quote("%"+value))
                 elif op=="all":                  elif op=="all":
                     tmps=[]                      tmps=[]
                     for word in value.split(" "):                      for word in value.split(" "):
                         tmps.append(name+" LIKE "+libpq.PgQuoteString("%"+word+"%"))                          tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
                                                   
                     tmp=string.join(tmps,' AND ')                      tmp=string.join(tmps,' AND ')
                                           
                 op="ct"                  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 (not tableExt) or (namealt.split('.')[0]==tableExt):                  if (not tableExt) or (namealt.split('.')[0]==tableExt):
                     if searchFields.has_key(name):                      if searchFields.has_key(namealt):
                         searchFields[name]+=lopfields.get(name,'OR')+" "+tmp                          searchFields[namealt]+=lopfields.get(name,'OR')+" "+tmp
                         searchFieldsOnly[name]+=lopfields.get(name,'OR')+" "+value                          searchFieldsOnly[namealt]+=lopfields.get(name,'OR')+" "+value
                     else:                       else: 
                         searchFields[name]=tmp                          searchFields[namealt]=tmp
                         searchFieldsOnly[name]=value                          searchFieldsOnly[namealt]=value
   
               
        ##  for name in searchFields.keys():  
 ##             value=searchFields[name]  
                   
 ##             if opfields.has_key(name):  
 ##                 op=opfields[name]  
 ##             else:  
 ##                 op="ct"  
 ##             name="LOWER("+name+")"      
 ##             if op=="ct":  
 ##                 whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))  
 ##             elif op=="gt":  
 ##                 whereList.append(name+">"+libpq.PgQuoteString(value))  
 ##             elif op=="lt":  
 ##                 whereList.append(name+"<"+libpq.PgQuoteString(value))  
 ##             elif op=="eq":  
 ##                 whereList.append(name+"="+libpq.PgQuoteString(value))  
 ##             elif op=="bw":  
 ##                 whereList.append(name+" LIKE "+libpq.PgQuoteString(value+"%"))  
 ##             elif op=="ew":  
 ##                 whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value))  
 ##             op="ct"  
                           
 ##             #except:  
 ##             #    print "END",value,name,Exception        
   
         whereList=["("+searchFields[x]+")" for x in searchFields.keys()]          whereList=["("+searchFields[x]+")" for x in searchFields.keys()]
           whereList+=queryTemplate
   
         if len(whereList)>0:          if len(whereList)>0:
             if filter:              if filter:
Line 682  class ZSQLExtendFolder(Folder,Persistent Line 1562  class ZSQLExtendFolder(Folder,Persistent
                 where+="and "+restrictConnect[0]+" in ("+restrictConnect[1]+")"                  where+="and "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
                                   
         #print "QE",table          #print "QE",table
                   #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']
             if not self.REQUEST.SESSION.has_key(storename):              if not self.REQUEST.SESSION.has_key(storename):
                 self.REQUEST.SESSION[storename]={}                  self.REQUEST.SESSION[storename]={}
   
               self.REQUEST.SESSION[storename]['qs']=qs #sichere Querystring
           
             if self.REQUEST.SESSION[storename].has_key('queryString2'):              if self.REQUEST.SESSION[storename].has_key('queryString2'):
   
                 if not self.REQUEST.SESSION[storename]['queryString2']==query2:                  if not self.REQUEST.SESSION[storename]['queryString2']==query2:
                     #print "HOOOOO",storename                      #print "HOOOOO",storename
                     self.REQUEST.SESSION[storename]['queryString2']=query2                      self.REQUEST.SESSION[storename]['queryString2']=query2
                       try:
                     self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count                      self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
                       except:
                           self.REQUEST.SESSION[storename]['count']=0
                     #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']                      #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']
                                   
             else:              else:
   
                 self.REQUEST.SESSION[storename]['queryString2']=query2                  self.REQUEST.SESSION[storename]['queryString2']=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:
                       self.REQUEST.SESSION[storename]['count']=0
                 #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']                  #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
                           
                           
             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 not NoQuery:          if not NoQuery:
Line 728  class ZSQLExtendFolder(Folder,Persistent Line 1623  class ZSQLExtendFolder(Folder,Persistent
   
             return query              return query
                           
     def ZSQLQuery(self,query):      def ZSQLUniqueQuery(self,value,returns):
           """unique relation"""
           if returns:
               statement="""select %s from %s where %s = '%s' """%(returns[1],returns[0],returns[2],value)
               founds=self.ZSQLSimpleSearch(statement)
               if founds:
                   return getattr(founds[0],returns[1])
               else:
                   return value
           else:
               return value
           
       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
         
           #zerlege querystring in key value paare
           #TODO: check if this is really necessary, use argv**
   
         for querytemp in querys:          rq=self.REQUEST['QUERY_STRING']
           querys=rq.split("&")
           for querytemp in querys: #zerg
             query=querytemp.split("=")              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 774  class ZSQLExtendFolder(Folder,Persistent Line 1690  class ZSQLExtendFolder(Folder,Persistent
                                                                                                   
     def nextLink(self,html,storename="foundCount"):      def nextLink(self,html,storename="foundCount"):
         """nextLink"""          """nextLink"""
   
         try:          try:
             limit=self.REQUEST.SESSION[storename]['rangeSize']              limit=self.REQUEST.SESSION[storename]['rangeSize']
             if int(limit)==0 :              if int(limit)==0 :
Line 783  class ZSQLExtendFolder(Folder,Persistent Line 1700  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 792  class ZSQLExtendFolder(Folder,Persistent Line 1709  class ZSQLExtendFolder(Folder,Persistent
         if self.REQUEST['QUERY_STRING']=="":          if self.REQUEST['QUERY_STRING']=="":
             qs=self.REQUEST.SESSION['query']              qs=self.REQUEST.SESSION['query']
                           
             queries=string.split(qs,",")              queries=string.split(qs,",")[0:]
                           
                           
         else:          else:
             qs=self.REQUEST['QUERY_STRING']              qs=self.REQUEST['QUERY_STRING']
             queries=string.split(qs,"&")              queries=string.split(qs,"&")[0:]
                           
                           
                           
Line 807  class ZSQLExtendFolder(Folder,Persistent Line 1724  class ZSQLExtendFolder(Folder,Persistent
                   
         for query in queries:          for query in queries:
                           
             #print query.split("=")[0]              if query[0]=="_" : query="-"+query[1:]
             if query[0]=="_" : query[0]="-"  
   
             if query.split("=")[0].lower()=="-skip":              if query.split("=")[0].lower()=="-skip":
   
Line 821  class ZSQLExtendFolder(Folder,Persistent Line 1737  class ZSQLExtendFolder(Folder,Persistent
             newquery.append(query)              newquery.append(query)
                                   
         newquerystring=string.join(newquery,"&")          newquerystring=string.join(newquery,"&")
           return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)
           
         return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)  
                           
                   
     def prevLink(self,html,storename="foundCount"):      def prevLink(self,html,storename="foundCount"):
         """prev link"""          """prev link"""
   
         try:          try:
             limit=self.REQUEST.SESSION[storename]['rangeSize']              limit=self.REQUEST.SESSION[storename]['rangeSize']
             if int(limit)==0 :              if int(limit)==0 :
Line 847  class ZSQLExtendFolder(Folder,Persistent Line 1764  class ZSQLExtendFolder(Folder,Persistent
                   
         if self.REQUEST['QUERY_STRING']=="":          if self.REQUEST['QUERY_STRING']=="":
             qs=self.REQUEST.SESSION['query']              qs=self.REQUEST.SESSION['query']
             #qs=re.sub(r'_','-',qs) #aendern für query              #qs=re.sub(r'_','-',qs) #aendern fuer query
             queries=string.split(qs,",")              queries=string.split(qs,",")
                           
                           
Line 878  class ZSQLExtendFolder(Folder,Persistent Line 1795  class ZSQLExtendFolder(Folder,Persistent
                           
         newquerystring=string.join(newquery,"&")          newquerystring=string.join(newquery,"&")
   
         return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)          return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)
   
   
       
     def prevLink_old(self,html):  
         """prev link"""  
         if self.REQUEST['QUERY_STRING']=="":  
             qs=self.REQUEST.SESSION['query']  
         else:  
             qs=self.REQUEST['QUERY_STRING']  
         max=re.search(r'max\=(.*)\,',qs.lower())  
         offset=re.search(r'offset\=(.*)\,',qs.lower())  
         if not offset:  
             offsetnew=0  
         else:  
             offsetnew=int(offset)-max  
             if offsetnew<0:  
                 offsetnew=0  
         queries=string.split(qs,",")  
         newquery=[]  
         if offset:  
             for query in queries:  
                 if query.split("=")[0].lower()=="offset":  
                     query="-offset=%i"%offsetnew  
                 newquery.append(query)  
                 newquerystring=string.join(newquery,"&")  
         else:  
             queries.append("-offset=%i"%offsetnew)  
             newquerystring=string.join(queries,"&")  
         return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)  
           
     def nextLink_old(self,html):  
         """prev link"""  
         if self.REQUEST['QUERY_STRING']=="":  
             qs=self.REQUEST.SESSION['query']  
         else:  
             qs=self.REQUEST['QUERY_STRING']  
         max=re.search(r'max\=(.*)\,',qs.lower())  
       
         offset=re.search(r'offset\=(.*)\,',qs.lower())  
         if not offset:  
             offsetnew=1  
         else:  
             offsetnew=int(offset)+int(max)  
             if offsetnew<0:  
                 offsetnew=0  
         queries=string.split(qs,",")  
         newquery=[]  
         if offset:  
             for query in queries:  
   
                 if query.split("=")[0].lower()=="-offset":  
                     query="-offset=%i"%offsetnew  
                 newquery.append(query)  
                 newquerystring=string.join(newquery,"&")  
         else:  
             queries.append("-offset=%i"%offsetnew)  
             newquerystring=string.join(queries,"&")  
                   
         return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)  
                   
           
 manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())  manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())
Line 1003  class ZSQLBibliography(Folder,ZSQLExtend Line 1863  class ZSQLBibliography(Folder,ZSQLExtend
                           
     def changeZSQLBibliographyForm(self):      def changeZSQLBibliographyForm(self):
         """change folder config"""          """change folder config"""
         pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLBibliographyForm.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeZSQLBibliographyForm.zpt')).__of__(self)
         return pt()          return pt()
   
   
Line 1014  class ZSQLBibliography(Folder,ZSQLExtend Line 1874  class ZSQLBibliography(Folder,ZSQLExtend
             obj=getattr(self,"ZSQLBibliography_template")              obj=getattr(self,"ZSQLBibliography_template")
             return obj()              return obj()
         except:          except:
             pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt').__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ZSQLBibliography_template_standard.zpt')).__of__(self)
             pt.content_type="text/html"              pt.content_type="text/html"
             return pt()              return pt()
   
     def changeZSQLBibliography(self,tableName,label,description,REQUEST=None):      def changeZSQLBibliography(self,tableName,label,description,connection_id=None,REQUEST=None):
         """change it"""          """change it"""
           self.connection_id=connection_id
         self.tableName=tableName          self.tableName=tableName
         self.label=label          self.label=label
         self.description=description          self.description=description
Line 1029  class ZSQLBibliography(Folder,ZSQLExtend Line 1890  class ZSQLBibliography(Folder,ZSQLExtend
   
     manage_options=Folder.manage_options+(      manage_options=Folder.manage_options+(
         {'label':'Main Config','action':'changeZSQLBibliographyForm'},          {'label':'Main Config','action':'changeZSQLBibliographyForm'},
           {'label':'Generate RDF Template','action':'generateRDFTemplate'},
           {'label':'Generate XML Template','action':'generateXMLTemplate'},
        )         )
   
   
Line 1093  class ZSQLBibliography(Folder,ZSQLExtend Line 1956  class ZSQLBibliography(Folder,ZSQLExtend
   
         return retdata,fieldlist          return retdata,fieldlist
   
       def createRDFTag(self,tag,content,namespace="cdli"):
           """create RDF"""
           if content:
               tag=namespace+":"+tag
               if (type(content) is StringType) or (type(content) is UnicodeType):
                   ret=""" <%s>%s</%s>"""%(tag,escape(content),tag)
               else:
                   ret=""" <%s>%s</%s>"""%(tag,content,tag)
               return ret.decode('latin-1')
           else:
               return ""
       
     def createIndexTag(self,tag,content):      def createIndexTag(self,tag,content):
         """creste tag"""          """create tag"""
           
         if content:          if content:
               if (type(content) is StringType) or (type(content) is UnicodeType):
                   ret=""" <%s>%s</%s>"""%(tag,escape(content),tag)
               else:
             ret="""<%s>%s</%s>"""%(tag,content,tag)              ret="""<%s>%s</%s>"""%(tag,content,tag)
             return ret              return ret.decode('latin-1')
   
         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]+"."
         self.REQUEST['fn']=fn          self.REQUEST['fn']=fn
   
         pt=PageTemplateFile('Products/ZSQLExtend/zpt/record2.xml').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record2.xml')).__of__(self)
           pt.content_type="text/xml"
           return pt()
   
   
       def generateRDFTemplate(self,REQUEST=None):
           """generateRDFtemplate"""
           zt=ZopePageTemplate('record.rdf')
           self._setObject('record.rdf',zt)
           default_content_fn = os.path.join(package_home(globals()),
                                             'zpt','record.rdf')
           text = open(default_content_fn).read()
           zt.pt_edit(text, 'text/xml')
   
   
           if REQUEST is not None:
               return self.manage_main(self, REQUEST)
   
       def generateXMLTemplate(self,REQUEST=None):
           """generateXMLtemplate"""
           zt=ZopePageTemplate('record.xml')
           self._setObject('record.xml',zt)
           default_content_fn = os.path.join(package_home(globals()),
                                             'zpt','record.xml')
           text = open(default_content_fn).read()
           zt.pt_edit(text, 'text/xml')
   
   
           if REQUEST is not None:
               return self.manage_main(self, REQUEST)
       def getMetaDataRDF(self):
           """crate index meta"""
           find=self.ZopeFind(self,obj_ids=["record.rdf"])
           if not find:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.rdf')).__of__(self)
         pt.content_type="text/xml"          pt.content_type="text/xml"
         return pt()          return pt()
           else:
               return find[0][1]()
   
     def getMetaDataXML(self):      def getMetaDataXML(self):
         """crate index meta"""          """crate index meta"""
         pt=PageTemplateFile('Products/ZSQLExtend/zpt/record.xml').__of__(self)          find=self.ZopeFind(self,obj_ids=["record.xml"])
           if not find:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.xml')).__of__(self)
         pt.content_type="text/xml"          pt.content_type="text/xml"
         return pt()          return pt()
           else:
               return find[0][1]()
   
   
     def getMetaDatasXML(self):      def getMetaDatasXML(self):
         """index"""          """index"""
           # check if the request's host part was OK
           http_host = self.REQUEST['HTTP_HOST']
           host_port = self.REQUEST['SERVER_PORT']
           fix_host = None
           if http_host and http_host.rfind(host_port) == -1:
               #print "HTTP_HOST needs fixing!"
               fix_host = http_host + ":" + host_port
           
         ret="""<?xml version="1.0" ?>          ret="""<?xml version="1.0" ?>
                  <index>"""                   <index>"""
         for found in self.ZSQLSimpleSearch("select oid from %s limit ALL"%self.tableName):          for found in self.ZSQLSimpleSearch("select oid from %s limit ALL"%self.tableName):
             link=self.absolute_url()+"/"+"record.html?oid=%i"%found.oid              base_url = self.absolute_url()
             metalink=self.absolute_url()+"/"+"getMetaDataXML?oid=%i"%found.oid              if fix_host:
                   #print "replacing ", http_host, " by ", fix_host
                   base_url = string.replace(base_url, http_host, fix_host, 1)
                   
               link=base_url+"/"+"record.html?oid=%i"%found.oid
               metalink=base_url+"/"+"getMetaDataXML?oid=%i"%found.oid
                           
             ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)              ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)
                           
Line 1135  manage_addZSQLBibliographyForm=DTMLFile( Line 2069  manage_addZSQLBibliographyForm=DTMLFile(
 def manage_addZSQLBibliography(self, id, tableName,label,description,title='',  def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
                      createPublic=0,                       createPublic=0,
                      createUserF=0,                       createUserF=0,
                        connection_id=None,
                      REQUEST=None):                       REQUEST=None):
     """Add a new Folder object with id *id*.      """Add a new Folder object with id *id*.
   
Line 1152  def manage_addZSQLBibliography(self, id, Line 2087  def manage_addZSQLBibliography(self, id,
     setattr(ob,'tableName',tableName)      setattr(ob,'tableName',tableName)
     setattr(ob,'label',label)      setattr(ob,'label',label)
     setattr(ob,'description',description)      setattr(ob,'description',description)
       setattr(ob,'connection_id',connection_id)
           
     checkPermission=getSecurityManager().checkPermission      checkPermission=getSecurityManager().checkPermission
   
Removed from v.1.34  
changed lines
  Added in v.1.105

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