ZSQLExtend/ZSQLExtend.py - diff

Return to ZSQLExtend.py CVS log

Up to [Repository] / ZSQLExtend

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.82 and 1.116

version 1.82, 2006/04/24 16:09:52	version 1.116, 2007/05/25 15:01:32
Line 4 from Globals import DTMLFile,package_hom	Line 4 from Globals import DTMLFile,package_hom
import urllib	import urllib
import re	import re
import string	import string
import sys
#from pyPgSQL import libpq	#from pyPgSQL import libpq
from AccessControl import getSecurityManager	from AccessControl import getSecurityManager,Unauthorized
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate	from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Products.PageTemplates.PageTemplateFile import PageTemplateFile	from Products.PageTemplates.PageTemplateFile import PageTemplateFile

Line 14 from Products.ZSQLMethods.SQL import SQL	Line 13 from Products.ZSQLMethods.SQL import SQL
from xml.sax.saxutils import escape	from xml.sax.saxutils import escape
from types import *	from types import *
import Shared.DC.ZRDB.DA	import Shared.DC.ZRDB.DA
import zLOG	import logging
import os.path	import os.path
import os	import os
	import copy
	import unicodedata
	import tempfile
	import sys

	#ersetzt logging
	def logger(txt,method,txt2):
	"""logging"""
	logging.info(txt+ txt2)


from OFS.SimpleItem import SimpleItem	from OFS.SimpleItem import SimpleItem

def getTextFromNode(nodename):	def getTextFromNode(nodename):
	"""get the cdata content of a node"""
	if nodename is None:
	return ""
nodelist=nodename.childNodes	nodelist=nodename.childNodes
rc = ""	rc = ""
for node in nodelist:	for node in nodelist:
Line 27 def getTextFromNode(nodename):	Line 40 def getTextFromNode(nodename):
rc = rc + node.data	rc = rc + node.data
return rc	return rc


def analyseIntSearch(word):	def analyseIntSearch(word):
#analyse integer searches	#analyse integer searches

Line 57 def sql_quote(v):	Line 69 def sql_quote(v):
def showSQLConnectionIDs(self):	def showSQLConnectionIDs(self):
return SQLConnectionIDs(self)	return SQLConnectionIDs(self)

	class Options:
	"""options class"""

class ZSQLIndex(SimpleItem):	class ZSQLIndex(SimpleItem):
"""index"""	"""index"""
meta_type="ZSQLIndex"	meta_type="ZSQLIndex"
Line 73 class ZSQLIndex(SimpleItem):	Line 88 class ZSQLIndex(SimpleItem):
return self.index	return self.index

class ZSQLExtendFolder(Folder,Persistent, Implicit):	class ZSQLExtendFolder(Folder,Persistent, Implicit):
"""Folder"""	"""Klasse die Methoden fuer die Abfrage einer SQL-Datenbank zur Verfuegung stellt.

	"""
meta_type="ZSQLExtendFolder"	meta_type="ZSQLExtendFolder"

def ZSQLQuote(self,str):	def ZSQLQuote(self,str):
"""quote str for sql"""	"""quote str for sql"""
return sql_quote(str)	return sql_quote(str)


	def normalizeField(self,table,fieldname, newFieldName=None,mode="alter", RESPONSE=None):
	"""normalize a field, d.h. entfernt alle diakritischen Zeichen und ersetzt diese
	durch den Grundbuchstaben in einer Spalte einer Tabelle
	@param table: Tabellename
	@param fieldname: Name der Spalte
	@param newFieldName: (optional) default ist fieldname+"_normal"
	@param mode: (optional) default ist "alter". Mode "alter" aendert ein bestehendes Feld newFieldName, mode "create" erzeugt diese zuerst.
	"""
	import unicodedata

	if not newFieldName:
	newFieldName=fieldname+"_normal"

	#normalisierungs routine
	def normal(str):
	if str:
	return unicodedata.normalize('NFKD', str.decode('utf-8')).encode('ASCII', 'ignore')
	else:
	return ""

	if mode=="create": # create the field
	qstr="""alter table %s add %s %s"""
	self.ZSQLSimpleSearch(qstr%(table,newFieldName,'text'))

	qstr="select oid,%s from %s"%(fieldname,table)
	for result in self.ZSQLSimpleSearch(qstr):
	qstr="update %s set %s = %s where oid = %s"

	self.ZSQLSimpleSearch(qstr%(table,newFieldName,self.ZSQLQuote(normal(getattr(result,fieldname))),result.oid))

def importAccessModell(self,configFileName,RESPONSE=None):	def importAccessModell(self,configFileName,RESPONSE=None):
"""import tables from access	"""import tables from access
@param configFileName: xml-configfile	@param configFileName: xml-configfile
Line 102 class ZSQLExtendFolder(Folder,Persistent	Line 150 class ZSQLExtendFolder(Folder,Persistent
containers=db.xpath("./@container")	containers=db.xpath("./@container")
identifiers=db.xpath("./@identify")	identifiers=db.xpath("./@identify")

print containers
if not (len(containers)==1):	if not (len(containers)==1):
return False	return False
else:	else:
Line 124 class ZSQLExtendFolder(Folder,Persistent	Line 172 class ZSQLExtendFolder(Folder,Persistent
@param elementNameForTable: must be a element of type complex type. the element of the sequence in the complex type	@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<	define the columns of the table >table<
@param data (optional): data to be imported	@param data (optional): data to be imported

@param filename (optional) or filename	@param filename (optional) or filename
@param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.	@param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
@param RESPONSE: (optional)	@param RESPONSE: (optional)
Line 132 class ZSQLExtendFolder(Folder,Persistent	Line 181 class ZSQLExtendFolder(Folder,Persistent
#from xml.dom.minidom import parseString,parse	#from xml.dom.minidom import parseString,parse

from Ft.Xml import Parse	from Ft.Xml import Parse
zLOG.LOG("import xsd",zLOG.INFO,"called")	logger("import xsd",logging.INFO,"called")
#fh=file("/tmp/fmpxml.xml")	#fh=file("/tmp/fmpxml.xml")
import bz2	import bz2
import base64	import base64
Line 142 class ZSQLExtendFolder(Folder,Persistent	Line 191 class ZSQLExtendFolder(Folder,Persistent
if data:	if data:
data=bz2.decompress(base64.decodestring(data))	data=bz2.decompress(base64.decodestring(data))

#zLOG.LOG("import xsd",zLOG.INFO,"received file")	#logger("import xsd",logging.INFO,"received file")
doc=Parse(data)	doc=Parse(data)
#zLOG.LOG("import xsd",zLOG.INFO,"parsed file")	#logger("import xsd",logging.INFO,"parsed file")

elif filename:	elif filename:
fh=file(filename)	fh=file(filename)
txt=fh.read()	txt=fh.read()

doc=Parse(txt)	doc=Parse(txt)
#zLOG.LOG("import xsd",zLOG.INFO,"parsed file")	#logger("import xsd",logging.INFO,"parsed file")


Nss={'xsd':'http://www.w3.org/2001/XMLSchema'}	Nss={'xsd':'http://www.w3.org/2001/XMLSchema'}
Line 170 class ZSQLExtendFolder(Folder,Persistent	Line 219 class ZSQLExtendFolder(Folder,Persistent
else:	else:
create=False	create=False

zLOG.LOG("update xsd: fieldnames",zLOG.INFO,repr(fieldNames))	logger("update xsd: fieldnames",logging.INFO,repr(fieldNames))
qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s' """	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)]	columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]

Line 185 class ZSQLExtendFolder(Folder,Persistent	Line 234 class ZSQLExtendFolder(Folder,Persistent
for fieldName in fieldNames:	for fieldName in fieldNames:
if type(fieldName) is UnicodeType:	if type(fieldName) is UnicodeType:
fieldName=fieldName.encode('utf-8')	fieldName=fieldName.encode('utf-8')
zLOG.LOG("update xml: fieldname",zLOG.INFO,repr(fieldName))	logging.info("update xml: fieldname",logging.INFO,repr(fieldName))
if fieldName.lower() not in columns:	if fieldName.lower() not in columns:

if create:# table does not exist therefore create with one column	if create:# table does not exist therefore create with one column
Line 195 class ZSQLExtendFolder(Folder,Persistent	Line 244 class ZSQLExtendFolder(Folder,Persistent
qstr="""alter table %s add %s %s"""	qstr="""alter table %s add %s %s"""

self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))	self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
zLOG.LOG("update xsd: fieldname add",zLOG.INFO,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):	def importXMLFileAccess(self,table,container,data=None,identify=None,filename=None,RESPONSE=None):
Line 209 class ZSQLExtendFolder(Folder,Persistent	Line 258 class ZSQLExtendFolder(Folder,Persistent
'''	'''
from xml.dom.pulldom import parseString,parse	from xml.dom.pulldom import parseString,parse

zLOG.LOG("import xml",zLOG.INFO,"called")	logger("import xml",logging.INFO,"called")
#fh=file("/tmp/fmpxml.xml")	#fh=file("/tmp/fmpxml.xml")
import bz2	import bz2
import base64	import base64
Line 218 class ZSQLExtendFolder(Folder,Persistent	Line 267 class ZSQLExtendFolder(Folder,Persistent
if data:	if data:
data=bz2.decompress(base64.decodestring(data))	data=bz2.decompress(base64.decodestring(data))

zLOG.LOG("import xml",zLOG.INFO,"received file")	logger("import xml",logging.INFO,"received file")
doc=parseString(data)	doc=parseString(data)
zLOG.LOG("import xml",zLOG.INFO,"parsed file")	logger("import xml",logging.INFO,"parsed file")

elif filename:	elif filename:
fh=file(filename)	fh=file(filename)
doc=parse(fh)	doc=parse(fh)
zLOG.LOG("import xml",zLOG.INFO,"parsed file")	logger("import xml",logging.INFO,"parsed file")
while 1:	while 1:
node=doc.getEvent()	node=doc.getEvent()

Line 240 class ZSQLExtendFolder(Folder,Persistent	Line 289 class ZSQLExtendFolder(Folder,Persistent
if col.nodeType is col.ELEMENT_NODE:	if col.nodeType is col.ELEMENT_NODE:
data=col.nodeName	data=col.nodeName
dataSet[data]=getTextFromNode(col)	dataSet[data]=getTextFromNode(col)
print dataSet.keys()
update=False	update=False

if identify:	if identify:
Line 248 class ZSQLExtendFolder(Folder,Persistent	Line 297 class ZSQLExtendFolder(Folder,Persistent
field=dataSet[identify]	field=dataSet[identify]

searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)	searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)
zLOG.LOG("import xml",zLOG.INFO,searchStr)	logger("import xml",logging.INFO,searchStr)
search=self.ZSQLSimpleSearch(searchStr)	search=self.ZSQLSimpleSearch(searchStr)
if search:	if search:
update=True	update=True
Line 262 class ZSQLExtendFolder(Folder,Persistent	Line 311 class ZSQLExtendFolder(Folder,Persistent
field=dataSet[identify]	field=dataSet[identify]

queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)	queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)
zLOG.LOG("update xml",zLOG.INFO,queryStr)	logger("update xml",logging.INFO,queryStr)
self.ZSQLSimpleSearch(queryStr)	self.ZSQLSimpleSearch(queryStr)
ret+="ud: %s \n"%field	ret+="ud: %s \n"%field
else:


	else:
fields=",".join(dataSet.keys())	fields=",".join(dataSet.keys())
values=",".join([""" %s """%self.ZSQLQuote(dataSet[x]) for x in dataSet.keys()])	values=",".join([""" %s """%self.ZSQLQuote(dataSet[x]) for x in dataSet.keys()])


queryStr="""INSERT INTO %s (%s) VALUES (%s)"""%(table,fields,values)	queryStr="""INSERT INTO %s (%s) VALUES (%s)"""%(table,fields,values)
self.ZSQLSimpleSearch(queryStr)	self.ZSQLSimpleSearch(queryStr)
zLOG.LOG("update xml",zLOG.INFO,queryStr)	logger("update xml",logging.INFO,queryStr)




return ret	return ret


def importXMLFile(self,table,data=None,identify=None,filename=None,RESPONSE=None):	def importXMLFileFMP(self,table,dsn=None,uploadfile=None,update_fields=None,id_field=None,sync_mode=False,
#TODO: finish importXMLFile	lc_names=True,keep_fields=False,replace=False,ascii_db=False,
	redirect_url=None,RESPONSE=None):
'''	'''
Import XML file into the table	Import FileMaker XML file (FMPXMLRESULT format) into the table.
	@param dsn: database connection string
@param table: name of the table the xml shall be imported into	@param table: name of the table the xml shall be imported into
@param containerTagName: XML-Tag which describes a dataset	@param uploadfile: xmlfile file
@param data: data to be imported	@param update_fields: (optional) list of fields to update; default is to create all fields
@param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.	@param id_field: (optional) field which uniquely identifies an entry for updating purposes.
	@param sync_mode: (optional) really synchronise, i.e. delete entries not in XML file
	@param lc_names: (optional) lower case and clean up field names from XML
	@param keep_fields: (optional) don't add fields to SQL database
	@param ascii_db: (optional) assume ascii encoding in db
	@param replace: (optional) delete and re-insert data
@param RESPONSE: (optional)	@param RESPONSE: (optional)
	@param redirect_url: (optional) url for redirecting after the upload is done
'''	'''
from xml.dom.pulldom import parseString,parse

zLOG.LOG("import xml",zLOG.INFO,"called")	tfilehd,filename=tempfile.mkstemp()
#fh=file("/tmp/fmpxml.xml")	tfile=os.fdopen(tfilehd,'w')
import bz2	logging.info("import %s"%uploadfile)
import base64	for c in uploadfile.read():
	tfile.write(c)
ret=""	tfile.close()
if data:
data=bz2.decompress(base64.decodestring(data))	from importFMPXML import importFMPXML

zLOG.LOG("import xml",zLOG.INFO,"received file")	if not dsn:
doc=parseString(data)	dsn=self.getConnectionObj().connection_string
zLOG.LOG("import xml",zLOG.INFO,"parsed file")
	options=Options()
elif filename:	options.dsn=dsn
fh=file(filename)	options.table=table
doc=parse(fh)	options.filename=filename
zLOG.LOG("import xml",zLOG.INFO,"parsed file")	options.update_fields=update_fields
while 1:	options.id_field=id_field
node=doc.getEvent()	options.sync_mode=sync_mode
	options.lc_names=lc_names
if node is None:	options.replace_table=replace
break;	options.keep_fields=keep_fields
else:	options.ascii_db=ascii_db
if node[1].nodeName=='ROW':	options.replace_table=replace
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)
zLOG.LOG("import xml",zLOG.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)	importFMPXML(options)
zLOG.LOG("update xml",zLOG.INFO,queryStr)
self.ZSQLSimpleSearch(queryStr)
ret+="ud: %s \n"%field
else:

	os.remove(filename)

fields=",".join(fieldNames)	if RESPONSE and redirect_url:
values=",".join([""" %s """%self.ZSQLQuote(x) for x in dataSet])	RESPONSE.redirect(redirect_url)


queryStr="""INSERT INTO %s (%s) VALUES (%s)"""%(table,fields,values)	def generateIndex(self,field,index_name,table,RESPONSE=None):
self.ZSQLSimpleSearch(queryStr)	"""erzeuge ein Index Objekt einem Feld (experimental)
zLOG.LOG("update xml",zLOG.INFO,queryStr)	@param field: Feldname zu dem ein Index erzeugt werden soll
ret+="ad: %s \n"%field	@param index_name: Name des Index
	@param table: Tabellen name"""
elif node[1].nodeName=="METADATA":
fieldNames=[]
doc.expandNode(node[1])

names=node[1].getElementsByTagName('FIELD')

for name in names:
fieldNames.append(name.getAttribute('NAME'))

zLOG.LOG("update xml: fieldnames",zLOG.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:
zLOG.LOG("update xml: fieldname",zLOG.INFO,repr(fieldName))
if fieldName not in columns:
qstr="""alter table %s add %s %s"""
self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
zLOG.LOG("update xml: fieldname add",zLOG.INFO,qstr%(table,fieldName,'text'))
#fn=node[1].getAttribute("xml:id")
#nf=file("xtf/"+fn+".xtf",'w')
#nf.write("""<texts xmlns="http://emegir.info/xtf" xmlns:lem="http://emegir.info/lemma" >"""+node[1].toxml()+"</texts>")
#print "wrote: %s"%fn
return ret

def generateIndex(self,field,index_name,table,RESPONSE=None):
"""erzeuge index aus feld"""
index={}	index={}
founds=self.ZSQLSimpleSearch("""SELECT %s,oid FROM %s LIMIT 2000"""%(field,table))	founds=self.ZSQLSimpleSearch("""SELECT %s,oid FROM %s """%(field,table))

for found in founds:	for found in founds:
tmp=getattr(found,field,None)	tmp=getattr(found,field,None)
Line 408 class ZSQLExtendFolder(Folder,Persistent	Line 407 class ZSQLExtendFolder(Folder,Persistent
self._getOb(index_name).setIndex(index)	self._getOb(index_name).setIndex(index)

def getIndex(self,index_name):	def getIndex(self,index_name):
"""getIndex"""	"""getIndex from index_name
	return an indexObject with index_name
	"""

founds=self.ZopeFind(self,obj_ids=[index_name])	founds=self.ZopeFind(self,obj_ids=[index_name])

return founds[0][1].getIndex()	return founds[0][1].getIndex()


def testneu(self):
"""test"""
relStatement="""period like '%s%%'"""
statement="select * from cdli_cat"
wherePart="museum_no like 'VAT%'"
classes=['Uruk III','Uruk IV']
return self.searchRel(relStatement,statement,wherePart,classes)

def URLquote(self,txt):	def URLquote(self,txt):
"""urlquote"""	"""urlquote"
	@param txt: text der urlgequoted werden soll.
	"""
return urllib.quote(txt)	return urllib.quote(txt)

def searchRel(self,relStatement,statement,wherePart,classes):	def searchRel(self,relStatement,statement,wherePart,classes):
"""suche relative haufigkeiten"""	"""suche relative haufigkeiten (experimental)"""
ret={}	ret={}
allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))	allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))

Line 437 class ZSQLExtendFolder(Folder,Persistent	Line 433 class ZSQLExtendFolder(Folder,Persistent
return (ret,allRecords)	return (ret,allRecords)

def content_html(self):	def content_html(self):
"""template fuer content"""	"""template fuer content_html Aufruf, notwendig fuer Kompatibiliaet bei gemeinsamem Einsatz mich ECHO-Produkt"""

try:	try:
obj=getattr(self,"ZSQLBibliography_template")	obj=getattr(self,"ZSQLBibliography_template")
Line 450 class ZSQLExtendFolder(Folder,Persistent	Line 446 class ZSQLExtendFolder(Folder,Persistent


def getWeight(self):	def getWeight(self):
"""getLabe"""	"""getWeight, gewicht notwendig fuer Kompatibiliaet bei gemeinsamem Einsatz mich ECHO-Produkt"""
try:	try:
return self.weight	return self.weight
except:	except:
return ""	return ""

def getLabel(self):	def getLabel(self):
"""getLabel"""	"""getLabel notwendig fuer Kompatibiliaet bei gemeinsamem Einsatz mich ECHO-Produkt"""
try:	try:
return self.label	return self.label
except:	except:
return ""	return ""

def getTitle(self):
"""getTitle"""
try:
return self.title
except:
return ""


def getDescription(self):	def getDescription(self):
"""getDescription"""	"""getDEscription: notwendig fuer Kompatibiliaet bei gemeinsamem Einsatz mich ECHO-Produkt"""
try:	try:
return self.description	return self.description
except:	except:
Line 489 class ZSQLExtendFolder(Folder,Persistent	Line 477 class ZSQLExtendFolder(Folder,Persistent


def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):	def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):
"""change it"""	"""change the Konfiguration"""
self.connection_id=connection_id	self.connection_id=connection_id
self.weight=weight	self.weight=weight
self.label=label	self.label=label
Line 499 class ZSQLExtendFolder(Folder,Persistent	Line 487 class ZSQLExtendFolder(Folder,Persistent
return self.manage_main(self, REQUEST)	return self.manage_main(self, REQUEST)

def formatAscii(self,str,url=None):	def formatAscii(self,str,url=None):
"""ersetze ascii umbrueche durch <br>"""	"""ersetze ascii umbrueche durch <br>
	@param str: string der Formatiert werden soll.
	@param url: (optional) default ist "None", sonderfall erzeugt einen Link aus String mit unterliegender url
	"""
#url=None	#url=None

if not str:
return ""

str=str.rstrip().lstrip()	str=str.rstrip().lstrip()

if url and str:	if url and str:
Line 560 class ZSQLExtendFolder(Folder,Persistent	Line 547 class ZSQLExtendFolder(Folder,Persistent
"""oinly for demo"""	"""oinly for demo"""
return os.path.splitext(path)[0]+".jpg"	return os.path.splitext(path)[0]+".jpg"

def ZSQLisEmpty(self,field):	def ZSQLisEmpty(self,str):
"""Teste ob Treffer leer"""	"""Teste ob String leer bzw. none ist.
	"""
#print "field",field	#print "field",field
if not field:	if not str:
return 1	return 1
if field=="":	if str.strip()=="":
return 1	return 1
return 0	return 0

	def ZSQLMultiSearch(self,_table,_searchField,_value,_idField,_additionalStatement="",_select=None,_subselectAddition="",_storename=None):
	"""
	Durchsucht in einer Tabelle "table" die Spalte "searchfield" nach dem allen Vorkommnissen
	von Worten in value und gibt alle Werte mit gleichem id field zur�ck, d.h. es wird die "und" suche �ber mehrere Eintrsege in einer
	Tabelle mit gleichem idField werd realisiert,
	z.B. f�r simplesearch ueber mehrere Felder
	@param _table: Tabelle, die durchsucht werden soll.
	@param _searchField: Feld, das durchsucht wird
	@param _value: String der gesucht werden soll, gesucht wird nach allen Worten des Strings, die durch " "-getrennt sind.
	@param _idField: Feld mit id f�r die identifikation gleicher Eintr�ge
	@param _additionalStatement: (optional) Zusaetzliches SQL Statement, dass zwischen dem ersten "select from" und dem ersten "where" eingegef�gt wird.
	@param _select: (optional) Alternativer Wert f�r den ersten SELECT Aufruf.
	@param _storename: (optional) Name fuer die Zwischenspeicherung von Werten in der Session
	"""
	if _storename:
	"""store"""
	else:
	_storename="foundCount"

	queries=[]
	#baue jede einzelne abfrage
	splitted=_value.split(" ")
	if not _select:
	_select=_idField

	query="select %s from %s %s where lower(%s) like '%%%s%%'"%(_select,_table,_additionalStatement,_searchField,splitted[0].lower())

	if len(splitted)>1: # mehr als ein Wort
	query+=" and %s in"%_idField # dann einschraenken
	for v in splitted[1:]:
	queries.append("select %s from %s %s where lower(%s) like '%%%s%%'"%(_idField,_table,_subselectAddition,_searchField,v.lower()))


	intersect=" intersect ".join(queries) # nun baue sie zusammen
	query+="(%s)"%intersect


	logging.info("ZSQLSimple: %s"%query)
	retT=self.ZSQLSimpleSearch(query)
	logging.info("ZSQLSimple: %s"%retT)

	#das Ergebis enthaelt unter u.U. eine id mehrfach, dieses wir jetzt vereinheitlicht.

	retFinalT={}
	for x in retT:
	split=_idField.split(".")
	if len(split)>1:
	f=split[1]
	else:
	f=_idField

	retFinalT[getattr(x,f)]=x

	ret=list(retFinalT.values())


	#aus Kompatibilaetsgruenen mit ZSQLSearch / ZSQLInlineSeach noch einzelne Felder in der SESSION belegen.
	if not self.REQUEST.SESSION.has_key(_storename):
	self.REQUEST.SESSION[_storename]={}

	self.REQUEST.SESSION[_storename]['searchFieldsOnly']={}
	self.REQUEST.SESSION[_storename]['qs']=query
	return ret

def ZSQLsearchOptions(self,fieldname=""):	def ZSQLsearchOptions(self,fieldname=""):
"""return HTML Fragment with search options"""	"""return HTML Fragment with search options"""

Line 581 class ZSQLExtendFolder(Folder,Persistent	Line 633 class ZSQLExtendFolder(Folder,Persistent
return ret	return ret

def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):	def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
"""generate select options from a cr seperated list"""	"""generate selection HTML Fragemnt from a cr seperated list
	@param fieldname: Wert fuer das "name"-Attribute der erzeugten input-Tags
	@param listField: "cr" (\n) getrennte Liste der Werte
	@param boxType: (optional) default ist "checkbox", moegliche Werte "checkbox" und "radio"
	@param checked: "cr" getrennt Liste von Werten aus listField, die als ausgewahlt markiert werden sollen.
	"""
fields=listField.split("\n")	fields=listField.split("\n")
ret=""	ret=""
for field in fields:	for field in fields:
Line 592 class ZSQLExtendFolder(Folder,Persistent	Line 649 class ZSQLExtendFolder(Folder,Persistent
return ret	return ret

def ZSQLSelectionFromSearchList(self,fieldname,results,fieldnameResult,boxType="checkbox",checked=None):	def ZSQLSelectionFromSearchList(self,fieldname,results,fieldnameResult,boxType="checkbox",checked=None):
"""generate select options from a cr seperated list"""	"""generate select options from research-results Objekt
	generate selection HTML Fragemnt from a cr seperated list
	@param fieldname: Wert fuer das "name"-Attribute der erzeugten input-Tags
	@param results: result Object einer SQL-suche
	@param fieldNameResult: Feldname des Resultobjekts, das angezeigt werden soll.
	@param boxType: (optional) default ist "checkbox", moegliche Werte "checkbox" und "radio"
	@param checked: "cr" getrennt Liste von Werten aus results.fieldNameResult, die als ausgewahlt markiert werden sollen.
	"""

ret=""	ret=""
if not results: return ""	if not results: return ""
Line 632 class ZSQLExtendFolder(Folder,Persistent	Line 696 class ZSQLExtendFolder(Folder,Persistent
ret+="""</select>"""	ret+="""</select>"""
return ret	return ret

def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None,additionalSelect="",size=None,linelen=None,selected=None):	def ZSQLOptionsFromSearchList(self,fieldname,
	results,fieldName,
	valueName=None,start=None,
	multiple='',startValue=None,
	additionalSelect="",size=None,
	linelen=None,selected=None,
	clear=False):
"""generate select options form a search list	"""generate select options form a search list
es wird	es wird
<select name=fieldname mutiple>	<select name=fieldname mutiple>
Line 640 class ZSQLExtendFolder(Folder,Persistent	Line 710 class ZSQLExtendFolder(Folder,Persistent
<option value=result.fieldName>result.fieldValue</option>	<option value=result.fieldName>result.fieldValue</option>
erzeugt.	erzeugt.

@parameter fieldname: Name fuer name-wert im select-tag	@param fieldname: Name fuer name-wert im select-tag
@results results: Resultobject einer SQL-suche	@param results: Resultobject einer SQL-suche
@parameter fieldName: Name des Feldes, das als value in den option-tag geschrieben werden soll.	@param fieldName: Name des Feldes, das als value in den option-tag geschrieben werden soll.
@parameter valueName: (optional) Name des Feldes, dass als im option-tag ausgegeben wird, default wert ist valueName=fieldName	@param valueName: (optional) Name des Feldes, dass als im option-tag ausgegeben wird, default wert ist valueName=fieldName
@start: (optional) falls zusaetzliches option tag erzeugt werden soll, gibt start an was im option tag steht	@param start: (optional) falls zusaetzliches option tag erzeugt werden soll, gibt start an was im option tag steht
@startValue: gibt den entsprechenden Wert an.	@param startValue (optional): gibt den entsprechenden Wert an.
	@param selected (optional): Wert der ausgewaehlt sein soll.
	@param linelen: (optional) maximale laenge eines Eintrages
	der im Klappmenue noch angezeigt wird, laengeres wird abgeschnitten.
	@param addionalSaelect (optional): zusaetzlicher text fuer den select tag
	@param clear (optional): setze auf den startwert.
"""	"""
if not valueName:	if not valueName:
valueName=fieldName	valueName=fieldName
Line 662 class ZSQLExtendFolder(Folder,Persistent	Line 737 class ZSQLExtendFolder(Folder,Persistent
if not startValue:	if not startValue:
startValue=start	startValue=start

	if clear:
	ret+="""<option selected value="%s" >%s</option>"""%(startValue,start)
	else:
ret+="""<option value="%s" >%s</option>"""%(startValue,start)	ret+="""<option value="%s" >%s</option>"""%(startValue,start)

for result in results:	for result in results:
field=getattr(result,fieldName)	field=getattr(result,fieldName)
fieldValue=getattr(result,valueName)	fieldValue=getattr(result,valueName)
if fieldValue:
print "XXX",field,repr(type(field)),repr(type(selected))
if not linelen:

if field == selected:	if linelen and fieldValue and (len(fieldValue) > string.atoi(linelen)):
print "huhu"	displayValue = fieldValue[:string.atoi(linelen)]
ret+="""<option value="%s" selected>%s</option>"""%(field,fieldValue)
else:	else:
ret+="""<option value="%s">%s</option>"""%(field,fieldValue)	displayValue = fieldValue

	if displayValue: #show only if value not none
	if field == selected:

	ret+="""<option value="%s" selected>%s</option>"""%(field,displayValue)
else:	else:
mist = """%s"""%(fieldValue)	ret+="""<option value="%s">%s</option>"""%(field,displayValue)
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:
Line 693 class ZSQLExtendFolder(Folder,Persistent	Line 771 class ZSQLExtendFolder(Folder,Persistent
else:	else:
storename="foundCount"	storename="foundCount"

	if args:
	argTmp=args
	else:
	argTmp=argv


#print "INLINE:",argv	#print "INLINE:",argv
for a in argv.keys():	for a in argTmp.keys():
qs.append(a+"="+urllib.quote(str(argv[a])))	aFiltered=re.sub(r"^-","_",a) # beginning of a command should always be "_"
	qs.append(aFiltered+"="+urllib.quote(str(argTmp[a])))
#return []	#return []
ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)	ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)

Line 706 class ZSQLExtendFolder(Folder,Persistent	Line 789 class ZSQLExtendFolder(Folder,Persistent
except:	except:
return None	return None

def ZSQLInlineSearch(self,storename=None,**argv):
	def ZSQLSequentialSearch(self,_fieldlist,_searchTerm,storename=None,args=None,**argv):
	"""get a list of tuples (fields,searchoptions,table) to search the searchTerm in, returns dictionary. """
	#print "do search with:",_fieldlist,_searchTerm,storename,args,argv
	ret={}
	if args:
	argTmp=args
	else:
	argTmp=argv

	for field in _fieldlist:

	argTmp2=copy.deepcopy(argTmp)
	argTmp2[field[0]]=_searchTerm
	argTmp2['_op_'+field[0]]=field[1]
	argTmp2['_table']=field[2]

	ret[field[0]]=(self.ZSQLInlineSearch(storename=storename,args=argTmp2),field[3],field[4],field[5],field[6])

	return ret


	def ZSQLInlineSearch(self,storename=None,args=None,**argv):
"""inlinesearch"""	"""inlinesearch"""

qs=[]	qs=[]
Line 717 class ZSQLExtendFolder(Folder,Persistent	Line 822 class ZSQLExtendFolder(Folder,Persistent



	if args:
	argTmp=args
	else:
	argTmp=argv


#print "INLINE:",argv	#print "INLINE:",argv
for a in argv.keys():	for a in argTmp.keys():
try:	aFiltered=re.sub(r"^-","_",a) # beginning of a command should always be "_"
qs.append(a+"="+urllib.quote(str(argv[a])))
except:	if type(argTmp[a]) is ListType: # ein parameter zweimal
import urllib	value=""
qs.append(a+"="+urllib.quote(str(argv[a])))	#TODO find a better solution, currently only the last non empty entry is used.
	for x in argTmp[a]:
	if x:
	value=x
	else:

	value=str(argTmp[a])
	qs.append(aFiltered+"="+urllib.quote(value))


#return []	#return []

return self.parseQueryString(string.join(qs,","),"_",storename=storename)	return self.parseQueryString(string.join(qs,","),"_",storename=storename)

def ZSQLInlineSearch2(self,query):	def ZSQLInlineSearch2(self,query):
Line 741 class ZSQLExtendFolder(Folder,Persistent	Line 861 class ZSQLExtendFolder(Folder,Persistent
try:	try:
self.getConnectionObj().manage_close_connection()	self.getConnectionObj().manage_close_connection()
except:	except:
zLOG.LOG("ZSQLResetConnection",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])	logger("ZSQLResetConnection",logging.ERROR, '%s %s'%sys.exc_info()[:2])
try:	try:
self.getConnectionObj().manage_open_connection()	self.getConnectionObj().manage_open_connection()
except:	except:
zLOG.LOG("ZSQLResetConnection",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])	logger("ZSQLResetConnection",logging.ERROR, '%s %s'%sys.exc_info()[:2])

def ZSQLSimpleSearch(self,query=None,max_rows=1000000,debug=None):	def ZSQLSimpleSearch(self,query=None,max_rows=1000000):
"""simple search"""	"""simple search"""
	logging.error("ZSQLSimpleSearch X %s"%query)
	#print query
if not query:	if not query:
query=self.query	query=self.query

if debug:
print "DEBUG: ZSQLSimpleSearch:", query
if (hasattr(self,"_v_searchSQL") and (self._v_searchSQL == None)) or (not hasattr(self,"_v_searchSQL")):	if (hasattr(self,"_v_searchSQL") and (self._v_searchSQL == None)) or (not hasattr(self,"_v_searchSQL")):

self._v_searchSQL=Shared.DC.ZRDB.DA.DA("_v_searchSQL","_v_searchSQL",self.getConnectionObj().getId(),"var","<dtml-var var>")	self._v_searchSQL=Shared.DC.ZRDB.DA.DA("_v_searchSQL","_v_searchSQL",self.getConnectionObj().getId(),"var","<dtml-var var>")

self._v_searchSQL.max_rows_=max_rows	self._v_searchSQL.max_rows_=max_rows
try:	try:
return self._v_searchSQL.__call__(var=query)	logging.error("I am here")
	t=self._v_searchSQL.__call__(var=query)
	logging.error("I am here %s"%t)
	return t
except :	except :
	logger("ZSQLSimpleSearch ERROR1",logging.ERROR, '%s %s'%sys.exc_info()[:2])
if sys.exc_info()[0]=="Database Error":	if sys.exc_info()[0]=="Database Error":
try:	try:
self.getConnectionObj().manage_open_connection()	self.getConnectionObj().manage_open_connection()
except:	except:
zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])	logger("ZSQLSimpleSearch ERROR2",logging.ERROR, '%s %s'%sys.exc_info()[:2])
else:	else:
try:	try:

Line 777 class ZSQLExtendFolder(Folder,Persistent	Line 899 class ZSQLExtendFolder(Folder,Persistent

return self._v_searchSQL.__call__(var=query)	return self._v_searchSQL.__call__(var=query)
except :	except :
	logger("ZSQLSimpleSearch ERROR2",logging.ERROR, '%s %s'%sys.exc_info()[:2])
if sys.exc_info()[0]=="Database Error":	if sys.exc_info()[0]=="Database Error":
try:	try:
self.getConnectionObj().manage_open_connection()	self.getConnectionObj().manage_open_connection()
except:	except:
zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])	logger("ZSQLSimpleSearch",logging.ERROR, '%s %s'%sys.exc_info()[:2])

def getConnectionObj(self):	def getConnectionObj(self):
if hasattr(self,'connection_id'):	if hasattr(self,'connection_id'):
Line 815 class ZSQLExtendFolder(Folder,Persistent	Line 937 class ZSQLExtendFolder(Folder,Persistent



def ZSQLAdd(self,format=None,RESPONSE=None,**argv):	def ZSQLAdd(self,format=None,RESPONSE=None,args=None,**argv):
"""Neuer Eintrag"""	"""Neuer Eintrag"""

	if args:
	argTmp=args
	else:
	argTmp=argv

qs_temp=[]	qs_temp=[]

for a in self.REQUEST.form.keys():	for a in self.REQUEST.form.keys():
Line 825 class ZSQLExtendFolder(Folder,Persistent	Line 952 class ZSQLExtendFolder(Folder,Persistent

qs=string.join(qs_temp,",")	qs=string.join(qs_temp,",")

for field in argv.keys():	for field in argTmp.keys():
if field[0]=="_":	if field[0]=="_":
fieldTmp="-"+field[1:]	fieldTmp="-"+field[1:]
else:	else:
fieldTmp=field	fieldTmp=field

qs+=",%s=%s"%(fieldTmp,argv[field])	qs+=",%s=%s"%(fieldTmp,argTmp[field])


addList={}	addList={}
Line 865 class ZSQLExtendFolder(Folder,Persistent	Line 992 class ZSQLExtendFolder(Folder,Persistent
else:	else:
return True	return True

def ZSQLChange(self,format=None,RESPONSE=None,USE_FORM=None,**argv):	def ZSQLChange(self,format=None,RESPONSE=None,USE_FORM=None,args=None,**argv):
"""change entries"""	"""change entries"""
#qs=self.REQUEST['QUERY_STRING']	#qs=self.REQUEST['QUERY_STRING']
# very bad hack	# very bad hack
Line 873 class ZSQLExtendFolder(Folder,Persistent	Line 1000 class ZSQLExtendFolder(Folder,Persistent
qs_temp=[]	qs_temp=[]
if USE_FORM or RESPONSE:	if USE_FORM or RESPONSE:
for a in self.REQUEST.form.keys():	for a in self.REQUEST.form.keys():

qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))	qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))


	if args:
	arg_tmp=args
	else:
	arg_tmp=argv

for field in argv.keys():	for field in arg_tmp.keys():

if field[0]=="_":	if field[0]=="_":
fieldTmp="-"+field[1:]	fieldTmp="-"+field[1:]
else:	else:
fieldTmp=field	fieldTmp=field

qs_temp.append("%s=%s"%(fieldTmp,argv[field]))	qs_temp.append("%s=%s"%(fieldTmp,arg_tmp[field]))


changeList=[]	changeList=[]
	logging.info("ZSQLChange qs_temp: %s"%repr(qs_temp))
for q in qs_temp:	for q in qs_temp:

name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))	name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
Line 900 class ZSQLExtendFolder(Folder,Persistent	Line 1032 class ZSQLExtendFolder(Folder,Persistent
table=urllib.unquote(value)	table=urllib.unquote(value)
elif name=="-identify":	elif name=="-identify":
identify=urllib.unquote(value)	identify=urllib.unquote(value)
identify=identify.split("=")[0]+"="+sql_quote(identify.split("=")[1])	identify="lower("+identify.split("=")[0]+")="+sql_quote(identify.split("=")[1].lower())
elif name=="-format":	elif name=="-format":
format=urllib.unquote(value)	format=urllib.unquote(value)
elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):	#elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
	elif (not (name[0]=="-" or name[0]=="_")):

	if value=="":
	changeList.append("\""+name+"\"=null")
	else:
changeList.append("\""+name+"\"="+sql_quote(urllib.unquote(value)))	changeList.append("\""+name+"\"="+sql_quote(urllib.unquote(value)))

changeString=string.join(changeList,",")	changeString=string.join(changeList,",")

queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)	queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
	logger("ZSQLExtend",logging.INFO,"CHANGE: "+queryString)

self.ZSQLSimpleSearch(queryString)	self.ZSQLSimpleSearch(queryString)

Line 920 class ZSQLExtendFolder(Folder,Persistent	Line 1057 class ZSQLExtendFolder(Folder,Persistent
return True	return True


def ZSQLFindIndexed(self,qs="",select="oid,",storename=None,indexedFields=['data_line'],restrictField='id_text',*argv):	def ZSQLFindIndexed(self,tableList=[],qs="",select="oid,",storename=None,indexedFields=['data_line'],restrictField='id_text',*argv):
"""find2"""	"""find2"""

for index in self.ZopeFind(self,obj_ids=indexedFields):	for index in self.ZopeFind(self,obj_ids=indexedFields):
Line 943 class ZSQLExtendFolder(Folder,Persistent	Line 1080 class ZSQLExtendFolder(Folder,Persistent



def ZSQLFind(self,qs="",select="oid,",storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,*argv):	def ZSQLFind(self,qs="",select="oid,",storename="foundCount",tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,*argv):
"""search in database"""	"""search in database"""

def delEmpty(list):	def delEmpty(list):
Line 966 class ZSQLExtendFolder(Folder,Persistent	Line 1103 class ZSQLExtendFolder(Folder,Persistent
if field[0]=="_":	if field[0]=="_":
fieldTmp="-"+field[1:]	fieldTmp="-"+field[1:]
else:	else:
fieldTmp=urllib.unquote(field)	fieldTmp=field

qs+=",%s=%s"%(fieldTmp,argv[field])	qs+=",%s=%s"%(fieldTmp,argv[field])

Line 995 class ZSQLExtendFolder(Folder,Persistent	Line 1132 class ZSQLExtendFolder(Folder,Persistent

qs=string.join(delEmpty(qs.split(",")),",")	qs=string.join(delEmpty(qs.split(",")),",")

if not storename:
storename="foundCount"

#store query for further usage	#store query for further usage
	#TODO: erste der beiden ist ueberfluessig
self.REQUEST.SESSION['query']=qs	self.REQUEST.SESSION['query']=qs
print "st",storename,qs	if not self.REQUEST.SESSION.has_key(storename):
	self.REQUEST.SESSION[storename]={}

	self.REQUEST.SESSION[storename]['qs']=qs


#print "calling Query with",repr(NoQuery)	#print "calling Query with",repr(NoQuery)

ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename,tableExt=tableExt,NoQuery=NoQuery,NoLimit=NoLimit,restrictField=restrictField,restrictConnect=restrictConnect,filter=filter)	ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename,tableExt=tableExt,NoQuery=NoQuery,NoLimit=NoLimit,restrictField=restrictField,restrictConnect=restrictConnect,filter=filter)
#print self.REQUEST.SESSION["foundCount"]	#print self.REQUEST.SESSION["foundCount"]

# if not hasattr(self,'_v_results'):
# self._v_results={}
#
#
# self._v_results[urllib.quote(qs)]=ret[0:]

return ret	return ret

def ZSQLFoundCountLen(self,var):	def ZSQLFoundCountLen(self,var):
return len(var)	return len(var)

def ZSQLFoundCount(self,qs="",select="*",storename=None):	def ZSQLFoundCount(self,qs="",select="*",storename="foundCount"):

## if qs=="":

## if self.REQUEST['QUERY_STRING']:

## qs=self.REQUEST['QUERY_STRING']
## qs=string.join(qs.split("&"),",")
## else:

## qs=self.REQUEST.SESSION['query']
## else:
## qs=string.join(qs.split("&"),",")


## temp= self.parseQueryString(qs,"-",select=select,storemax="yes",nostore="yes")
if storename:
"""store"""
else:
storename="foundCount"

return self.REQUEST.SESSION[storename]['count']	return self.REQUEST.SESSION[storename]['count']

def ZSQLRangeStart(self,storename=None):	def ZSQLRangeStart(self,storename="foundCount"):

if storename:
"""store"""
else:
storename="foundCount"

return int(self.REQUEST.SESSION[storename]['rangeStart'])+1	return int(self.REQUEST.SESSION[storename]['rangeStart'])+1

def ZSQLRangeSize(self,storename=None):	def ZSQLRangeSize(self,storename="foundCount"):

if storename:
"""store"""
else:
storename="foundCount"

return self.REQUEST.SESSION[storename]['rangeSize']	return self.REQUEST.SESSION[storename]['rangeSize']

def ZSQLRangeEnd(self,storename=None):	def ZSQLRangeEnd(self,storename="foundCount"):

if storename:
"""store"""
else:
storename="foundCount"

return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))	return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))

def ZSQLNewQuery(self,linkText,storename=None,**argv):	def ZSQLNewQuery(self,linkText,storename="foundCount",**argv):
"""suche neu"""	"""suche neu"""
return self.ZSQLNewSearch(linkText,storename,url=self.REQUEST['URL'],args=argv)	return self.ZSQLNewSearch(linkText,storename,url=self.REQUEST['URL'],args=argv)

def ZSQLNewSearch(self,linkText,storename=None,url=None,args=None,**argv):	def ZSQLNewSearch(self,linkText,storename="foundCount",url=None,args=None,**argv):
"""suche mit alten parametern bis auf die in argv getauschten"""	"""suche mit alten parametern bis auf die in argv getauschten"""
	str = self.ZSQLNewSearchURL(storename, url, args, **argv)
	return """<a href="%s"> %s</a>"""%(str,linkText)

if storename:
"""store"""
else:
storename="foundCount"
qs=self.REQUEST.SESSION[storename]['qs']

	def ZSQLNewSearchURL(self, storename="foundCount",url=None,args=None,**argv):
	"""suche mit alten parametern bis auf die in argv getauschten"""
if args:	if args:
argv=args	argv=args

	#get the old queries
	qs=self.REQUEST.SESSION[storename]['qs']
querys=qs.split(",")	querys=qs.split(",")
argList=[]
arg=""
queryList=[x.split("=")[0] for x in querys]

for argTmp in argv.keys():	#which arguments are in the old query string

	queryList={}
	for query in querys:
	arg=query.split("=")[0]
	if arg[0]=="_": arg="-"+arg[1:] # sicherstellen, dass an Anfang stets "_"
	try:
	queryList[arg]=query.split("=")[1]
	except:
	queryList[arg]=''

arg=argTmp[0:]	argList=[]
if arg[0]=="_":arg="-"+argTmp[1:] # aender _ in - als standard	arg=""

if arg not in queryList: # noch nicht drin
querys.append("%s=%s"%(arg,argv[argTmp]))
argList.append(arg)


	#gehe durch die zu aendernden Argumente
	for argTmp in argv.keys():

newquery=[]	arg=argTmp[0:]# sicherstellen, dass der string auh kopiert wird
for query in querys:	if arg[0]=="_": arg="-"+arg[1:] # sicherstellen, dass an Anfang stets "_"
queryArg=query.split("=")[0]
qarg=queryArg[0:]
if qarg[0]=="-":qarg="_"+queryArg[1:] # aender _ in - als standard

if queryArg in argList:	queryList[arg]=argv[argTmp]
newquery.append("%s=%s"%(queryArg,argv[qarg]))
else:
newquery.append(query)

if url:	if url:
str=url+"?"+"&".join(newquery)	str=url+"?"+urllib.urlencode(queryList)
else:	else:
str="ZSQLSearch?"+"&".join(newquery)	str="ZSQLSearch?"+urllib.urlencode(queryList)

return """<a href="%s"> %s</a>"""%(str,linkText)	return str

def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None):	def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename="foundCount",tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None):
"""analysieren den QueryString"""	"""analysieren den QueryString"""


Line 1132 class ZSQLExtendFolder(Folder,Persistent	Line 1235 class ZSQLExtendFolder(Folder,Persistent
opfields={}	opfields={}
lopfields={} #Verknuepfung bei mehrfachauswahl von einem feld	lopfields={} #Verknuepfung bei mehrfachauswahl von einem feld
sortfields={} #order of sortfields	sortfields={} #order of sortfields
	diacritics={} #diacritische zeichen, falls "no", dann werden diese fuer das feld gefiltert.
sortAllFields=None	sortAllFields=None
skip=""	skip=""
rangeStart=0	rangeStart=0
Line 1139 class ZSQLExtendFolder(Folder,Persistent	Line 1243 class ZSQLExtendFolder(Folder,Persistent
searchFields={}	searchFields={}
searchFieldsOnly={}	searchFieldsOnly={}
queryTemplate=[]	queryTemplate=[]
	outerjoin=""
	debug=None

if not select:	if not select:
select="oid,*"	select="oid,*"
Line 1157 class ZSQLExtendFolder(Folder,Persistent	Line 1263 class ZSQLExtendFolder(Folder,Persistent
for q in splitted:	for q in splitted:

name=re.sub("r'+'"," ",q.split("=")[0].lower())	name=re.sub("r'+'"," ",q.split("=")[0].lower())
	if name=="_debug":
	debug=True

try:	try:
value=urllib.unquote(q.split("=",1)[1])	value=urllib.unquote(q.split("=",1)[1])
except:	except:
Line 1174 class ZSQLExtendFolder(Folder,Persistent	Line 1283 class ZSQLExtendFolder(Folder,Persistent
field=name[5:]	field=name[5:]
lopfields[field]=lop	lopfields[field]=lop

	if name[0:11]==iCT+"diacritics":
	field=name[12:]
	diacritics[field]=value

if name[0:10]==iCT+"sortorder":	if name[0:10]==iCT+"sortorder":
#sort=value	#sort=value

Line 1191 class ZSQLExtendFolder(Folder,Persistent	Line 1304 class ZSQLExtendFolder(Folder,Persistent


name=re.sub("r'+'"," ",q.split("=")[0].lower())	name=re.sub("r'+'"," ",q.split("=")[0].lower())

try:	try:
value=urllib.unquote(q.split("=",1)[1])	value=urllib.unquote(q.split("=",1)[1])

except:	except:
value=""	value=""

punktsplit=name.split(".") #sonderfall feld mit punkten(tabelle.suchFeld.ausgewaehltesFeld,feldinoriginal), d.h. suche in anderer tabelle:	punktsplit=name.split(".") #sonderfall feld mit punkten(tabelle.suchFeld.ausgewaehltesFeld,feldinoriginal), d.h. suche in anderer tabelle:

#analysiere alle anderen faelle	#analysiere alle anderen faelle

	if diacritics.get(name,'yes')=='no':
	"""filter diacritische zeichen"""
	value=unicodedata.normalize('NFKD', value.decode('utf-8')).encode('ASCII', 'ignore')

if name==iCT+"lop":	if name==iCT+"lop":
lop=value	lop=value
elif name==iCT+"table":	elif name==iCT+"table":
Line 1215 class ZSQLExtendFolder(Folder,Persistent	Line 1335 class ZSQLExtendFolder(Folder,Persistent
skip="OFFSET "+str(value)	skip="OFFSET "+str(value)
rangeStart=str(value)	rangeStart=str(value)
elif name==iCT+"join":	elif name==iCT+"join":

whereList.append(value)	whereList.append(value)
	elif name==iCT+"outerjoin":

	outerjoin=value
elif name==iCT+"sort":	elif name==iCT+"sort":
sortstrs=[]	sortstrs=[]

for word in value.split(','):	for word in value.split(','):
wordstr=word.lstrip().rstrip()	wordstr=word.lstrip().rstrip()
if sortAllFields:	if sortAllFields:
Line 1239 class ZSQLExtendFolder(Folder,Persistent	Line 1364 class ZSQLExtendFolder(Folder,Persistent
op=value	op=value


	#sonderfall Name hat das Format:
	#TABELLE.SUCHFELD_IN_DIESER_TABELLE.SELECT_FIELD.IDENTIFIER_IN_TABELLE_-table
	#i.e. erzeugt wird
	#das Statement
	#WHERE IDENTIFIER_IN_TABELLE in (select * from SELECT_FIELD
	#where LOWER(SUCHFELD_IN_DIESER_TABELLE) something value)
	#something is defined by _op_TABELLE.SUCHFELD_IN_DIESER_TABELLE.SELECT_FIELD.IDENTIFIER_IN_TABELLE

elif (not name[0]==iCT) and len(punktsplit)==4:	elif (not name[0]==iCT) and len(punktsplit)==4:

if opfields.has_key(name):	if opfields.has_key(name):
op=opfields[name]	op=opfields[name]
else:	else:
op="ct"	op="ct"
namealt=name	namealt=name
name="LOWER("+punktsplit[1]+")"	name="LOWER("+punktsplit[1]+")"
	value=value.lower()
if op=="ct":	if op=="ct":
tmp=(name+" LIKE "+sql_quote("%"+value+"%"))	tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
elif op=="gt":	elif op=="gt":
Line 1279 class ZSQLExtendFolder(Folder,Persistent	Line 1412 class ZSQLExtendFolder(Folder,Persistent

tmp=string.join(tmps,' OR ')	tmp=string.join(tmps,' OR ')

searchFieldsOnly[namealt]=value
op="all"	op="all"

	if value!='': #lehre Werte werde nicht hinzugefuegt
searchTmp="""%s in (select %s from %s where %s)"""%(punktsplit[3],punktsplit[2],punktsplit[0],tmp)	searchTmp="""%s in (select %s from %s where %s)"""%(punktsplit[3],punktsplit[2],punktsplit[0],tmp)


queryTemplate.append(searchTmp)	queryTemplate.append(searchTmp)

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 1332 class ZSQLExtendFolder(Folder,Persistent	Line 1464 class ZSQLExtendFolder(Folder,Persistent

op="all"	op="all"

if (not tableExt) or (namealt.split('.')[0]==tableExt):	if (value!='') and ((not tableExt) or (namealt.split('.')[0]==tableExt)): #keine leeren werde und keine auschluss
if searchFields.has_key(namealt):	if searchFields.has_key(namealt):
searchFields[namealt]+=lopfields.get(name,'OR')+" "+tmp	searchFields[namealt]+=lopfields.get(name,'OR')+" "+tmp
searchFieldsOnly[namealt]+=lopfields.get(name,'OR')+" "+value	searchFieldsOnly[namealt]+=lopfields.get(name,'OR')+" "+value
Line 1365 class ZSQLExtendFolder(Folder,Persistent	Line 1497 class ZSQLExtendFolder(Folder,Persistent

#print "QE",table	#print "QE",table
#print (select,table,where,sort,maxstr,skip)	#print (select,table,where,sort,maxstr,skip)
query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)	query="SELECT %s FROM %s %s %s %s %s %s"%(select,table,outerjoin,where,sort,maxstr,skip)

if not nostore=="yes":	if not nostore=="yes":

self.REQUEST.SESSION['qs']=opfields	self.REQUEST.SESSION['qs']=opfields
#print "IAMHERE again:", query	#print "IAMHERE again:", query

if storename and (not NoQuery):	if not NoQuery:

query2="SELECT count(*) FROM %s %s"%(table,where)	query2="SELECT count(*) FROM %s %s"%(table,where)

Line 1397 class ZSQLExtendFolder(Folder,Persistent	Line 1529 class ZSQLExtendFolder(Folder,Persistent

self.REQUEST.SESSION[storename]['queryString2']=query2	self.REQUEST.SESSION[storename]['queryString2']=query2
if self.ZSQLSimpleSearch(query2):	if self.ZSQLSimpleSearch(query2):

self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count	self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
else:	else:
self.REQUEST.SESSION[storename]['count']=0	self.REQUEST.SESSION[storename]['count']=0
Line 1404 class ZSQLExtendFolder(Folder,Persistent	Line 1537 class ZSQLExtendFolder(Folder,Persistent


self.REQUEST.SESSION[storename]['rangeStart']=rangeStart	self.REQUEST.SESSION[storename]['rangeStart']=rangeStart
if limit=="all":

	self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']

	if (limit=="all") or (limit==int(limit)):
self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']	self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
else:	else:
self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)	self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
self.REQUEST.SESSION[storename]['rangeSize']=limit	self.REQUEST.SESSION[storename]['rangeSize']=limit
self.REQUEST.SESSION[storename]['searchFields']=searchFields	self.REQUEST.SESSION[storename]['searchFields']=searchFields
print "SF",searchFieldsOnly,searchFields
self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly

	self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly

	if debug:
	logging.error("ZSQLSimpleSearch %s"%query)
if not NoQuery:	if not NoQuery:

return self.ZSQLQuery(query)	return self.ZSQLQuery(query)
Line 1436 class ZSQLExtendFolder(Folder,Persistent	Line 1574 class ZSQLExtendFolder(Folder,Persistent
def ZSQLQuery(self,query,debug=None):	def ZSQLQuery(self,query,debug=None):
"""query"""	"""query"""
if debug:	if debug:
zLOG.LOG("ZSQLQuery", zLOG.INFO, query)	logger("ZSQLQuery", logging.INFO, query)

return self.ZSQLSimpleSearch(query)	return self.ZSQLSimpleSearch(query)

Line 1464 class ZSQLExtendFolder(Folder,Persistent	Line 1602 class ZSQLExtendFolder(Folder,Persistent
self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")	self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
self.REQUEST.SESSION['come_from_search']="yes"	self.REQUEST.SESSION['come_from_search']="yes"

return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))	return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile)+"?"+rq)


def ZSQLint(self,string):	def ZSQLint(self,string):
Line 1498 class ZSQLExtendFolder(Folder,Persistent	Line 1636 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 1597 class ZSQLExtendFolder(Folder,Persistent	Line 1735 class ZSQLExtendFolder(Folder,Persistent



def prevLink_old(self,html):
"""prev link"""
if self.REQUEST['QUERY_STRING']=="":
qs=self.REQUEST.SESSION['query']
else:
qs=self.REQUEST['QUERY_STRING']
max=re.search(r'max\=(.*)\,',qs.lower())
offset=re.search(r'offset\=(.*)\,',qs.lower())
if not offset:
offsetnew=0
else:
offsetnew=int(offset)-max
if offsetnew<0:
offsetnew=0
queries=string.split(qs,",")
newquery=[]
if offset:
for query in queries:
if query.split("=")[0].lower()=="offset":
query="-offset=%i"%offsetnew
newquery.append(query)
newquerystring=string.join(newquery,"&")
else:
queries.append("-offset=%i"%offsetnew)
newquerystring=string.join(queries,"&")
return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)

def nextLink_old(self,html):
"""prev link"""
if self.REQUEST['QUERY_STRING']=="":
qs=self.REQUEST.SESSION['query']
else:
qs=self.REQUEST['QUERY_STRING']
max=re.search(r'max\=(.*)\,',qs.lower())

offset=re.search(r'offset\=(.*)\,',qs.lower())
if not offset:
offsetnew=1
else:
offsetnew=int(offset)+int(max)
if offsetnew<0:
offsetnew=0
queries=string.split(qs,",")
newquery=[]
if offset:
for query in queries:

if query.split("=")[0].lower()=="-offset":
query="-offset=%i"%offsetnew
newquery.append(query)
newquerystring=string.join(newquery,"&")
else:
queries.append("-offset=%i"%offsetnew)
newquerystring=string.join(queries,"&")

return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)


manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())	manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())

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

Removed from v.1.82
changed lines
	Added in v.1.116