ZSQLExtend/ZSQLExtend.py - diff

Return to ZSQLExtend.py CVS log

Up to [Repository] / ZSQLExtend

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.20 and 1.49

version 1.20, 2004/06/11 16:54:29	version 1.49, 2004/11/03 14:52:30
Line 1	Line 1
from OFS.Folder import Folder	from OFS.Folder import Folder
from Globals import Persistent	from Globals import Persistent
from Acquisition import Implicit	from Acquisition import Implicit
from Globals import DTMLFile	from Globals import DTMLFile,package_home
import urllib	import urllib
import re	import re
import string	import string
from pyPgSQL import libpq	#from pyPgSQL import libpq
from AccessControl import getSecurityManager	from AccessControl import getSecurityManager
import os.path	import os.path
from Products.PageTemplates.PageTemplateFile import PageTemplateFile	from Products.PageTemplates.PageTemplateFile import PageTemplateFile

def quoteString(name):	from Products.ZSQLMethods.SQL import SQLConnectionIDs
#return re.sub(r'([\(\)\?])',"\\\1",name)	import Shared.DC.ZRDB.DA
#return "Euklid"
return name

	def analyseIntSearch(word):
	#analyse integer searches

	splitted=word.split("-")

class ZSQLExtendFolder(Persistent, Implicit, Folder):	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

	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 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 28 class ZSQLExtendFolder(Persistent, Impli	Line 71 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').__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 60 class ZSQLExtendFolder(Persistent, Impli	Line 104 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 162 class ZSQLExtendFolder(Persistent, Impli	Line 206 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,start=None):	def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None):
"""generate select oprions form a cr seperated list"""	"""generate select oprions form a search list seperated list"""
	if not valueName:
	valueName=fieldName

ret="""<select name="%s">	ret="""<select name="%s" %s>
"""%fieldname	"""%(fieldname,multiple)
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)
ret+="""<option value="%s">%s</option>"""%(field,field)	fieldValue=getattr(result,valueName)
	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 201 class ZSQLExtendFolder(Persistent, Impli	Line 272 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])))
	except:
	import urllib
qs.append(a+"="+urllib.quote(str(argv[a])))	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 212 class ZSQLExtendFolder(Persistent, Impli	Line 288 class ZSQLExtendFolder(Persistent, Impli


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


	def ZSQLSimpleSearch(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 235 class ZSQLExtendFolder(Persistent, Impli	Line 337 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 268 class ZSQLExtendFolder(Persistent, Impli	Line 370 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'],*argv):
	"""find2"""
	#search1= self.ZSQLFind(qs="",select="oid,",storename=None,tableExt='cdli_translit',restrictField='id_text',NoQuery='yes',NoLimit='yes',*argv)


	#search2 = self.ZSQLFind(tableExt='cdli_cat',qs="",select="oid,",storename=None,restrictConnect=('cdli_cat.id_text',search1),*argv)

	search1= self.ZSQLFind(qs="",select="oid,",storename=None,tableExt='cdli_cat',restrictField='id_text',NoQuery='yes',NoLimit='yes',*argv)

	search2 = self.ZSQLFind(tableExt='cdli_translit',qs="",select="oid,",storename=None,restrictConnect=('cdli_translit.id_text',search1),*argv)
	return search2

	#return self.ZSQLFind(qs="",select="oid,",storename=None,tableExt=None,NoQuery=None,*argv)

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

	def delEmpty(list):
	ret=[]
	for x in list:
	splitted=x.split("=")
	if (len(splitted)>1) and not (splitted[1]==' '):
	ret.append(x)
	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']


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

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

qs+=",-%s=%s"%(field,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():
	#print field
	qs+=",-%s=%s"%(field,argv[field])

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

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



qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.	qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.

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

if storename:	if storename:
"""store"""	"""store"""
else:	else:
storename="foundCount"	storename="foundCount"
#print "QS",qs
ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename)
	#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)
#print self.REQUEST.SESSION["foundCount"]	#print self.REQUEST.SESSION["foundCount"]


return ret	return ret

def ZSQLFoundCountLen(self,var):	def ZSQLFoundCountLen(self,var):
Line 387 class ZSQLExtendFolder(Persistent, Impli	Line 503 class ZSQLExtendFolder(Persistent, Impli
else:	else:
storename="foundCount"	storename="foundCount"

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

	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)

def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None):

	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 425 class ZSQLExtendFolder(Persistent, Impli	Line 603 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
Line 439 class ZSQLExtendFolder(Persistent, Impli	Line 635 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 457 class ZSQLExtendFolder(Persistent, Impli	Line 656 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 471 class ZSQLExtendFolder(Persistent, Impli	Line 683 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(name):
	searchFields[name]+=lopfields.get(name,'OR')+" "+tmp
	searchFieldsOnly[name]+=lopfields.get(name,'OR')+" "+value
	else:
	searchFields[name]=tmp
	searchFieldsOnly[name]=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 508 class ZSQLExtendFolder(Persistent, Impli	Line 761 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 535 class ZSQLExtendFolder(Persistent, Impli	Line 793 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 ZSQLQuery(self,query):	def ZSQLQuery(self,query):
"""query"""	"""query"""
return self.search(var=query)	#print "hi",query
	return self.ZSQLSimpleSearch(query)

def ZSQLSearch(self):	def ZSQLSearch(self):
"""To be done"""	"""To be done"""
Line 557 class ZSQLExtendFolder(Persistent, Impli	Line 821 class ZSQLExtendFolder(Persistent, Impli
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 571 class ZSQLExtendFolder(Persistent, Impli	Line 838 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 :
	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']-10	#newRangeStart=self.REQUEST.SESSION[storename]['count']-1
	return ""

#create new query string	#create new query string

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 611 class ZSQLExtendFolder(Persistent, Impli	Line 882 class ZSQLExtendFolder(Persistent, Impli
skipFound=0	skipFound=0

for query in queries:	for query in queries:
#print query.split("=")[0]
if query[0]=="_" : query[0]="-"	if query[0]=="_" : query="-"+query[1:]

if query.split("=")[0].lower()=="-skip":	if query.split("=")[0].lower()=="-skip":

skipFound=1	skipFound=1
query="-skip=%i"%newRangeStart	query="-skip=%i"%newRangeStart
newquery.append(query)	newquery.append(query)
Line 624 class ZSQLExtendFolder(Persistent, Impli	Line 896 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 :
	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 <0:
	return ""

#print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])	#print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])

Line 646 class ZSQLExtendFolder(Persistent, Impli	Line 923 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 677 class ZSQLExtendFolder(Persistent, Impli	Line 954 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 744 manage_addZSQLExtendFolderForm=DTMLFile(	Line 1021 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 760 def manage_addZSQLExtendFolder(self, id,	Line 1038 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 800 class ZSQLBibliography(Folder,ZSQLExtend	Line 1079 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 811 class ZSQLBibliography(Folder,ZSQLExtend	Line 1090 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 851 class ZSQLBibliography(Folder,ZSQLExtend	Line 1130 class ZSQLBibliography(Folder,ZSQLExtend
except:	except:
return None	return None

	def findTagsFromMapping(self,referenceType):
	"""gib hash mit label -> generic zurueck"""
	self.referencetypes=self.ZopeFind(self.standardMD)
	bibdata={}
	retdata={}
	fieldlist=self.standardMD.fieldList

	for referenceTypeF in self.referencetypes:
	#print referenceType,referenceTypeF[1].title
	if referenceTypeF[1].title == referenceType:
	bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
	bibdata['data']=referenceTypeF[1]
	self.fields=bibdata[referenceType]
	for field in fieldlist:
	if referenceTypeF[1].getValue(field)[0]==None:
	retdata[field]=field
	else:
	retdata[field]=referenceTypeF[1].getValue(field)[0]

	return retdata,fieldlist

def findLabelsFromMapping(self,referenceType):	def findLabelsFromMapping(self,referenceType):
"""gib hash mit label -> generic zurueck"""	"""gib hash mit label -> generic zurueck"""
self.referencetypes=self.ZopeFind(self.standardMD)	self.referencetypes=self.ZopeFind(self.standardMD)
Line 869 class ZSQLBibliography(Folder,ZSQLExtend	Line 1169 class ZSQLBibliography(Folder,ZSQLExtend

return retdata,fieldlist	return retdata,fieldlist

	def createIndexTag(self,tag,content):
	"""creste tag"""
	if content:
	ret="""<%s>%s</%s>"""%(tag,content,tag)
	return ret
	else:
	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 getMetaDataXML(self):
	"""crate index meta"""
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.xml')).__of__(self)
	pt.content_type="text/xml"
	return pt()

	def getMetaDatasXML(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="""<?xml version="1.0" ?>
	<index>"""
	for found in self.ZSQLSimpleSearch("select oid from %s limit ALL"%self.tableName):
	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)

	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)

	return ret+"\n</index>"


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

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

Removed from v.1.20
changed lines
	Added in v.1.49