ZSQLExtend/ZSQLExtend.py - diff

Return to ZSQLExtend.py CVS log

Up to [Repository] / ZSQLExtend

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.25 and 1.56

version 1.25, 2004/07/13 17:41:37	version 1.56, 2005/01/25 19:30:11
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.PageTemplateFile import PageTemplateFile	from Products.PageTemplates.PageTemplateFile import PageTemplateFile

	from Products.ZSQLMethods.SQL import SQLConnectionIDs
	import Shared.DC.ZRDB.DA
	import zLOG
	import os.path
	import os

	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=join(split(v,dkey),quote_dict[dkey])
	return "'%s'" % v

class ZSQLExtendFolder(Persistent, Implicit, Folder):	def showSQLConnectionIDs(self):
	return SQLConnectionIDs(self)

	class ZSQLExtendFolder(Folder,Persistent, Implicit):
"""Folder"""	"""Folder"""
meta_type="ZSQLExtendFolder"	meta_type="ZSQLExtendFolder"

	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):
	"""urlquote"""
	return urllib.quote(txt)
	def searchRel(self,relStatement,statement,wherePart,classes):
	"""suche relative haufigkeiten"""
	ret={}
	allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))

	for oneclass in classes:
	ret[oneclass]=len(self.ZSQLSimpleSearch(statement + " where ("+wherePart+") and "+ relStatement%oneclass))

	return (ret,allRecords)

def content_html(self):	def content_html(self):
"""template fuer content"""	"""template fuer content"""

Line 23 class ZSQLExtendFolder(Persistent, Impli	Line 77 class ZSQLExtendFolder(Persistent, Impli
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 56 class ZSQLExtendFolder(Persistent, Impli	Line 110 class ZSQLExtendFolder(Persistent, Impli

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()


def changeZSQLExtend(self,label,description,weight=0,REQUEST=None):	def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):
"""change it"""	"""change it"""
	self.connection_id=connection_id
self.weight=weight	self.weight=weight
self.label=label	self.label=label
self.description=description	self.description=description
Line 158 class ZSQLExtendFolder(Persistent, Impli	Line 212 class ZSQLExtendFolder(Persistent, Impli
return ret	return ret


def ZSQLOptionsFromCRList(self,fieldname,listField):	def ZSQLOptionsFromCRList(self,fieldname,listField, multiple=''):
"""generate select oprions form a cr seperated list"""	"""generate select oprions form a cr seperated list"""
fields=listField.split("\n")	fields=listField.split("\n")
ret="""<select name="%s">	ret="""<select name="%s" %s>
"""%fieldname	"""%(fieldname,multiple)
for field in fields:	for field in fields:
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):	def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None,additionalSelect=""):
"""generate select oprions form a cr 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.
	"""
if not valueName:	if not valueName:
valueName=fieldName	valueName=fieldName

ret="""<select name="%s">	ret="""<select name="%s" %s %s>
"""%fieldname	"""%(fieldname,multiple,additionalSelect)
if start:	if start:
if start==' ':	if start==' ':
start=''	start=''
ret+="""<option value="%s">%s</option>"""%(start,start)	if not startValue:
	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:
ret+="""<option value="%s">%s</option>"""%(field,fieldValue)	ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
ret+="""</select>"""	ret+="""</select>"""
return ret	return ret


	def ZSQLInlineSearchU(self,storename=None,**argv):
	"""one element if exists"""
	qs=[]
	if storename:
	"""store"""
	else:
	storename="foundCount"



	#print "INLINE:",argv
	for a in argv.keys():
	qs.append(a+"="+urllib.quote(str(argv[a])))
	#return []
	ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)

	try:
	return ret[0]
	except:
	return None

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

qs=[]	qs=[]
if storename:	if storename:
"""store"""	"""store"""
Line 200 class ZSQLExtendFolder(Persistent, Impli	Line 292 class ZSQLExtendFolder(Persistent, Impli

#print "INLINE:",argv	#print "INLINE:",argv
for a in argv.keys():	for a in argv.keys():
	try:
qs.append(a+"="+urllib.quote(str(argv[a])))	qs.append(a+"="+urllib.quote(str(argv[a])))
	except:
	import urllib
	qs.append(a+"="+urllib.quote(str(argv[a])))

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

Line 211 class ZSQLExtendFolder(Persistent, Impli	Line 308 class ZSQLExtendFolder(Persistent, Impli


#print "INLINE:",query	#print "INLINE:",query
	return self.ZSQLSimpleSearch(query)

	def ZSQLSimpleSearch(self,query=None):
	"""simple search"""
	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.connection_id,"var","<dtml-var var>")

	try:
	return self._v_searchSQL.__call__(var=query)
	except :
	if sys.exc_info()[0]=="Database Error":
	try:
	getattr(self,self.connection_id).manage_open_connection()
	except: pass
	else:
	try:
	return self._v_searchSQL.__call__(var=query)
	except :
	if sys.exc_info()[0]=="Database Error":
	try:
	getattr(self,self.connection_id).manage_open_connection()
	except: pass

	def ZSQLSimpleSearch2(self,query=None):
	""" returrn SQLSearch"""
	#print "hi",query
	if not query:
	query=self.query
	if getattr(self,'_v_search',None):

	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:
	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)
	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 []



def ZSQLAdd(self):	def ZSQLAdd(self):
"""Neuer Eintrag"""	"""Neuer Eintrag"""
Line 234 class ZSQLExtendFolder(Persistent, Impli	Line 380 class ZSQLExtendFolder(Persistent, Impli
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.search(var=queryString)	self.ZSQLSimpleSearch(queryString)
return self.REQUEST.RESPONSE.redirect(format)	return self.REQUEST.RESPONSE.redirect(format)

def ZSQLChange(self,**argv):	def ZSQLChange(self,**argv):
"""�ndern von Eintr�gen"""	"""change entries"""
#qs=self.REQUEST['QUERY_STRING']	#qs=self.REQUEST['QUERY_STRING']
# very bad hack	# very bad hack
qs_temp=[]	qs_temp=[]
Line 267 class ZSQLExtendFolder(Persistent, Impli	Line 413 class ZSQLExtendFolder(Persistent, Impli
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]=="-") and (not len(value)==0):
changeList.append("\""+name+"\"="+libpq.PgQuoteString(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)
self.search(var=queryString)	self.ZSQLSimpleSearch(queryString)
return self.REQUEST.RESPONSE.redirect(format)	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=[]
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.search(var=queryString)
return self.REQUEST.RESPONSE.redirect(format)

def ZSQLFind(self,qs="",select="oid,",storename=None,*argv):
	def ZSQLFind2(self,qs="",select="oid,",storename=None,tableList=['cdli_translit','cdli_cat'],restrictField='id_text',*argv):
	"""find2"""

	search1= self.ZSQLFind(qs=qs,select=select,storename=storename,tableExt=tableList[1],restrictField=restrictField,NoQuery='yes',NoLimit='yes',**argv)

	search2 = self.ZSQLFind(tableExt=tableList[0],qs=qs,select=select,storename=storename,restrictConnect=(tableList[0]+"."+restrictField,search1),**argv)
	return search2



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

def delEmpty(list):	def delEmpty(list):
Line 313 class ZSQLExtendFolder(Persistent, Impli	Line 446 class ZSQLExtendFolder(Persistent, Impli
ret.append(x)	ret.append(x)
return ret	return ret



	#self.REQUEST.SESSION['come_from_search']="no" # zuruecksetzen
if qs=="":	if qs=="":

if self.REQUEST['QUERY_STRING']:	if self.REQUEST['QUERY_STRING']:
qs=self.REQUEST['QUERY_STRING']	qs=self.REQUEST['QUERY_STRING']

Line 321 class ZSQLExtendFolder(Persistent, Impli	Line 458 class ZSQLExtendFolder(Persistent, Impli
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"%(fieldTmp,argv[field])

qs+=",-%s=%s"%(field,argv[field])
#print qs
else:	else:

qs=self.REQUEST.SESSION['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 347 class ZSQLExtendFolder(Persistent, Impli	Line 495 class ZSQLExtendFolder(Persistent, Impli
else:	else:
storename="foundCount"	storename="foundCount"

	#store query for further usage
	self.REQUEST.SESSION['query']=qs

	#print "calling Query with",repr(NoQuery)
ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename)	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"]



return ret	return ret

def ZSQLFoundCountLen(self,var):	def ZSQLFoundCountLen(self,var):
Line 408 class ZSQLExtendFolder(Persistent, Impli	Line 559 class ZSQLExtendFolder(Persistent, Impli

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 parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None):	def ZSQLNewQuery(self,linkText,storename=None,**argv):
	"""suche neu"""
	return self.ZSQLNewSearch(linkText,storename,url=self.REQUEST['URL'],args=argv)

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

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

	if args:
	argv=args

	querys=qs.split(",")
	argList=[]
	arg=""
	queryList=[x.split("=")[0] for x in querys]

	for argTmp in argv.keys():


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

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



	newquery=[]
	for query in querys:
	queryArg=query.split("=")[0]
	qarg=queryArg[0:]
	if qarg[0]=="-":qarg="_"+queryArg[1:] # aender _ in - als standard

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

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

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

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

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={} #Verknuepfung bei mehrfachauswahl von einem feld
	sortfields={} #order of sortfields
	sortAllFields=None
skip=""	skip=""
rangeStart=0	rangeStart=0
limit=0	limit=0
searchFields={}	searchFields={}
	searchFieldsOnly={}
if not select:	if not select:
select="oid,*"	select="oid,*"
#print "Q",nostore,qs	#print "Q",nostore,qs
#check for op in the case of inline search	#check for op




splitted=qs.split(",")	splitted=qs.split(",")
	if tableExt:
	table=tableExt

	if restrictField:
	select=restrictField

for q in splitted:	for q in splitted:

Line 444 class ZSQLExtendFolder(Persistent, Impli	Line 657 class ZSQLExtendFolder(Persistent, Impli

field=name[4:]	field=name[4:]
opfields[field]=op	opfields[field]=op

	if name[0:4]==iCT+"lop":
	lop=value

	field=name[5:]
	lopfields[field]=lop

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

	field=name[11:]
	sortAllFields=None
	#no field selected
	if field=="":
	sortAllFields=value
	else:
	sortfields[field]=value

#print "HI",op,field	#print "HI",op,field
#print opfieldsa	#print opfieldsa
#now analyse the querystring	#now analyse the querystring

for q in qs.split(","):	for q in qs.split(","):


Line 458 class ZSQLExtendFolder(Persistent, Impli	Line 690 class ZSQLExtendFolder(Persistent, Impli
except:	except:
value=""	value=""

#value=libpq.PgQuoteString(value)	#value=sql_quote(value)


if name==iCT+"lop":	if name==iCT+"lop":
lop=value	lop=value
elif name==iCT+"table":	elif name==iCT+"table":
	if not tableExt:
table=value	table=value
elif name==iCT+"select":	elif name==iCT+"select":
	if not restrictField:
select=value	select=value
elif name==iCT+"max":	elif name==iCT+"max":
	if not NoLimit:
maxstr="LIMIT "+str(value)	maxstr="LIMIT "+str(value)
limit=str(value)	limit=str(value)
elif name==iCT+"skip":	elif name==iCT+"skip":
Line 476 class ZSQLExtendFolder(Persistent, Impli	Line 711 class ZSQLExtendFolder(Persistent, Impli
elif name==iCT+"join":	elif name==iCT+"join":
whereList.append(value)	whereList.append(value)
elif name==iCT+"sort":	elif name==iCT+"sort":
sort="ORDER BY "+value	sortstrs=[]
	for word in value.split(','):
	wordstr=word.lstrip().rstrip()
	if sortAllFields:
	order=sortAllFields
	else:
	order=sortfields.get(wordstr,'ASC')

	if not (wordstr == ""):
	sortstrs.append(wordstr+" "+order)
	if len(sortstrs)>0:
	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 490 class ZSQLExtendFolder(Persistent, Impli	Line 738 class ZSQLExtendFolder(Persistent, Impli

#print "OP",op,name	#print "OP",op,name
value=value.lower()	value=value.lower()
	tmp=""
searchFields[name]=value

if opfields.has_key(name):	if opfields.has_key(name):
op=opfields[name]	op=opfields[name]
else:	else:
op="ct"	op="ct"
	namealt=name
name="LOWER("+name+")"	name="LOWER("+name+")"
if op=="ct":	if op=="ct":
whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))	tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
elif op=="gt":	elif op=="gt":
whereList.append(name+">"+libpq.PgQuoteString(value))	tmp=(name+">"+sql_quote(value))
elif op=="lt":	elif op=="lt":
whereList.append(name+"<"+libpq.PgQuoteString(value))	tmp=(name+"<"+sql_quote(value))
elif op=="eq":	elif op=="eq":
whereList.append(name+"="+libpq.PgQuoteString(value))	tmp=(name+"="+sql_quote(value))
elif op=="bw":	elif op=="bw":
whereList.append(name+" LIKE "+libpq.PgQuoteString(value+"%"))	tmp=(name+" LIKE "+sql_quote(value+"%"))
elif op=="ew":	elif op=="ew":
whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value))	tmp=(name+" LIKE "+sql_quote("%"+value))
op="ct"	elif op=="all":
	tmps=[]
	for word in value.split(" "):
	tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))

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

	elif op=="numerical":
	term=analyseIntSearch(value)
	tmp=(name+" "+term)
	elif op=="grep":
	tmp=(name+" ~* "+sql_quote(value))
	elif op=="one":
	tmps=[]
	for word in value.split(" "):
	tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))

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

	op="all"

	if (not tableExt) or (namealt.split('.')[0]==tableExt):
	if searchFields.has_key(namealt):
	searchFields[namealt]+=lopfields.get(name,'OR')+" "+tmp
	searchFieldsOnly[namealt]+=lopfields.get(name,'OR')+" "+value
	else:
	searchFields[namealt]=tmp
	searchFieldsOnly[namealt]=value


	whereList=["("+searchFields[x]+")" for x in searchFields.keys()]

#except:
# print "END",value,name,Exception
if len(whereList)>0:	if len(whereList)>0:
where="WHERE "+string.join(whereList," "+lop+" ")	if filter:
	whereStr="("+string.join(whereList," "+lop+" ")+") AND "+filter
	else:
	whereStr=string.join(whereList," "+lop+" ")
	where="WHERE "+whereStr
	else:
	if filter:
	where="WHERE "+filter
else:	else:
where=""	where=""
#print "QE",table

	if restrictConnect:

	if len(where)==0:
	where="WHERE "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
	else:
	where+="and "+restrictConnect[0]+" in ("+restrictConnect[1]+")"

	#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"%(select,table,where,sort,maxstr,skip)

if not nostore=="yes":	if not nostore=="yes":
Line 527 class ZSQLExtendFolder(Persistent, Impli	Line 817 class ZSQLExtendFolder(Persistent, Impli
self.REQUEST.SESSION['qs']=opfields	self.REQUEST.SESSION['qs']=opfields
#print "IAMHERE again:", query	#print "IAMHERE again:", query

if storename:	if storename and (not NoQuery):
query2="SELECT count(*) FROM %s %s"%(table,where)	query2="SELECT count(*) FROM %s %s"%(table,where)
#print "storing",query2
#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'):
#print "HI",storename
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
self.REQUEST.SESSION[storename]['count']=self.search(var=query2)[0].count	self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count

#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
self.REQUEST.SESSION[storename]['count']=self.search(var=query2)[0].count	self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
#print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']	#print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']


Line 554 class ZSQLExtendFolder(Persistent, Impli	Line 849 class ZSQLExtendFolder(Persistent, Impli
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

	if not NoQuery:

#print "Q",query
return self.ZSQLQuery(query)	return self.ZSQLQuery(query)
	else:

	return 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):	def ZSQLQuery(self,query):
"""query"""	"""query"""
return self.search(var=query)
	return self.ZSQLSimpleSearch(query)


def ZSQLSearch(self):	def ZSQLSearch(self):
"""To be done"""	"""To be done"""
rq=self.REQUEST['QUERY_STRING']	rq=self.REQUEST['QUERY_STRING']

querys=rq.split("&")	querys=rq.split("&")


	formatfile=self.REQUEST['URL1'] #generisch redirect zur gleichen url

for querytemp in querys:	for querytemp in querys:
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"""	"""nothing"""


#print formatfile	#print formatfile


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"

return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))	return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))


Line 590 class ZSQLExtendFolder(Persistent, Impli	Line 917 class ZSQLExtendFolder(Persistent, Impli
def getZSQLSearchFieldsList(self,storename="foundCount"):	def getZSQLSearchFieldsList(self,storename="foundCount"):
"""get searchfieldList"""	"""get searchfieldList"""
#print self.REQUEST.SESSION[storename]['searchFields'].keys()	#print self.REQUEST.SESSION[storename]['searchFields'].keys()
return self.REQUEST.SESSION[storename]['searchFields'].keys()	return self.REQUEST.SESSION[storename]['searchFieldsOnly'].keys()

def getZSQLSearchFields(self,storename="foundCount"):	def getZSQLSearchFields(self,field,storename="foundCount"):
"""get searchfield"""	"""get searchfield"""
#print "SF",self.REQUEST.SESSION[storename]['searchFields']	#print "SF",self.REQUEST.SESSION[storename]['searchFields']
return self.REQUEST.SESSION[storename]['searchFields']
	return self.REQUEST.SESSION[storename]['searchFieldsOnly'][field]


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 :
limit="1"	limit="1"
newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)	newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)
except:	except:
limit=0	limit=1
newRangeStart=0	newRangeStart=0

if newRangeStart>self.REQUEST.SESSION[storename]['count']:	if newRangeStart>=self.REQUEST.SESSION[storename]['count']:
#newRangeStart=self.REQUEST.SESSION[storename]['count']-1	#newRangeStart=self.REQUEST.SESSION[storename]['count']-1
return ""	return ""

Line 618 class ZSQLExtendFolder(Persistent, Impli	Line 947 class ZSQLExtendFolder(Persistent, Impli
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 633 class ZSQLExtendFolder(Persistent, Impli	Line 962 class ZSQLExtendFolder(Persistent, Impli

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":
print "d", newRangeStart
skipFound=1	skipFound=1
query="-skip=%i"%newRangeStart	query="-skip=%i"%newRangeStart
newquery.append(query)	newquery.append(query)
Line 647 class ZSQLExtendFolder(Persistent, Impli	Line 975 class ZSQLExtendFolder(Persistent, Impli
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 673 class ZSQLExtendFolder(Persistent, Impli	Line 1002 class ZSQLExtendFolder(Persistent, Impli

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 704 class ZSQLExtendFolder(Persistent, Impli	Line 1033 class ZSQLExtendFolder(Persistent, Impli

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)



Line 771 manage_addZSQLExtendFolderForm=DTMLFile(	Line 1100 manage_addZSQLExtendFolderForm=DTMLFile(
def manage_addZSQLExtendFolder(self, id, title='', label='', description='',	def manage_addZSQLExtendFolder(self, id, title='', label='', description='',
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 787 def manage_addZSQLExtendFolder(self, id,	Line 1117 def manage_addZSQLExtendFolder(self, id,
ob=self._getOb(id)	ob=self._getOb(id)
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

Line 827 class ZSQLBibliography(Folder,ZSQLExtend	Line 1158 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 838 class ZSQLBibliography(Folder,ZSQLExtend	Line 1169 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()

Line 917 class ZSQLBibliography(Folder,ZSQLExtend	Line 1248 class ZSQLBibliography(Folder,ZSQLExtend

return retdata,fieldlist	return retdata,fieldlist

	def createRDFTag(self,tag,content):
	"""create RDF"""
	if content:
	ret=""" <cdli:%s>%s</cdli:%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:
ret="""<%s>%s</%s>"""%(tag,content,tag)	ret="""<%s>%s</%s>"""%(tag,content,tag)
return ret	return ret
else:	else:
return ""	return ""

	def getMetaDataXML2(self):
	"""crate index meta"""

	fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
	self.REQUEST['fn']=fn

	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record2.xml')).__of__(self)
	pt.content_type="text/xml"
	return pt()

	def getMetaDataRDF(self):
	"""crate index meta"""
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.rdf')).__of__(self)
	pt.content_type="text/xml"
	return pt()

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 createVLMAtripels(self):
	"""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=""
	for found in self.ZSQLSimpleSearch("select id_text from %s limit ALL"%'cdli_cat'):
	base_url = self.absolute_url()
	if fix_host:
	#print "replacing ", http_host, " by ", fix_host
	base_url = string.replace(base_url, http_host, fix_host, 1)

	#found2=self.ZSQLInlineSearchU(_table="cdli_imglist",id_text=found.id_text)
	#create collectionobject info
	subject="http://xserve02.mpiwg-berlin.mpg.de:8880/cdlineu/cdli_coll/cdli2/cdli_templates/cdli_templates/textdisplay.html?-table=cdli_cat&id_text=%s"%found.id_text
	object="http://xserve02:8880/cdlidata/images/getMetaDataRDF?id_text=%s"%found.id_text
	predicate="metadata"
	ret+="%s\t%s\t%s\n"%(subject,object,predicate)
	#create image
	subject="http://xserve02.mpiwg-berlin.mpg.de:8880/cdlineu/cdli_coll/cdli2/cdli_templates/cdli_templates/textdisplay.html?-table=cdli_cat&id_text=%s"%found.id_text
	object="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn=/experimental/cdli/dl/photo/%s&mo=rawfile"%found.id_text
	predicate="image"

	ret+="%s\t%s\t%s\n"%(subject,object,predicate)

	#create thumb
	subject="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn=/experimental/cdli/dl/photo/%s&mo=rawfile"%found.id_text
	object="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn=/experimental/cdli/dl/photo/%s&dw=100&dh=100"%found.id_text
	predicate="thumb"

	ret+="%s\t%s\t%s\n"%(subject,object,predicate)

	return ret


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.search(var="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)

return ret+"\n</index>"	return ret+"\n</index>"


manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())	manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())

def manage_addZSQLBibliography(self, id, tableName,label,description,title='',	def manage_addZSQLBibliography(self, id, tableName,label,description,title='',

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

Removed from v.1.25
changed lines
	Added in v.1.56