1: from OFS.Folder import Folder
2: from Acquisition import Implicit
3: from Globals import DTMLFile,package_home,Persistent
4: import urllib
5: import re
6: import string
7: import sys
8: #from pyPgSQL import libpq
9: from AccessControl import getSecurityManager
10: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
11: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
12:
13: from Products.ZSQLMethods.SQL import SQLConnectionIDs
14: from xml.sax.saxutils import escape
15: from types import *
16: import Shared.DC.ZRDB.DA
17: import zLOG
18: import os.path
19: import os
20: import copy
21: import unicodedata
22:
23: from OFS.SimpleItem import SimpleItem
24:
25: def getTextFromNode(nodename):
26: """get the cdata content of a node"""
27: if nodename is None:
28: return ""
29: nodelist=nodename.childNodes
30: rc = ""
31: for node in nodelist:
32: if node.nodeType == node.TEXT_NODE:
33: rc = rc + node.data
34: return rc
35:
36: def analyseIntSearch(word):
37: #analyse integer searches
38:
39: splitted=word.split("-")
40:
41: if len(splitted)==1:
42: return "="+splitted[0]
43:
44: if splitted[0]=="":
45: return "< "+splitted[1]
46:
47: if splitted[1]=='':
48: return "> "+splitted[0]
49: else:
50: return "BETWEEN "+splitted[0]+" AND "+splitted[1]
51:
52:
53:
54: def sql_quote(v):
55: # quote dictionary
56: quote_dict = {"\'": "''", "\\": "\\\\"}
57: for dkey in quote_dict.keys():
58: if string.find(v, dkey) >= 0:
59: v=string.join(string.split(v,dkey),quote_dict[dkey])
60: return "'%s'" % v
61:
62: def showSQLConnectionIDs(self):
63: return SQLConnectionIDs(self)
64:
65: class ZSQLIndex(SimpleItem):
66: """index"""
67: meta_type="ZSQLIndex"
68:
69: def __init__(self,index,id,table=''):
70: self.index=[x for x in index]
71: self.id=id
72: self.table=table
73:
74: def setIndex(self,index):
75: self.index=[x for x in index]
76:
77: def getIndex(self):
78: return self.index
79:
80: class ZSQLExtendFolder(Folder,Persistent, Implicit):
81: """Folder"""
82: meta_type="ZSQLExtendFolder"
83:
84: def ZSQLQuote(self,str):
85: """quote str for sql"""
86: return sql_quote(str)
87:
88:
89: def normalizeField(self,table,fieldname, newFieldName=None,mode="alter", RESPONSE=None):
90: """normalize a field"""
91: import unicodedata
92:
93: if not newFieldName:
94: newFieldName=fieldname+"_normal"
95:
96: def normal(str):
97: if str:
98: return unicodedata.normalize('NFKD', str.decode('utf-8')).encode('ASCII', 'ignore')
99: else:
100: return ""
101: if mode=="create": # create the field
102: qstr="""alter table %s add %s %s"""
103: self.ZSQLSimpleSearch(qstr%(table,newFieldName,'text'))
104:
105: qstr="select oid,%s from %s"%(fieldname,table)
106: for result in self.ZSQLSimpleSearch(qstr):
107: qstr="update %s set %s = %s where oid = %s"
108:
109: self.ZSQLSimpleSearch(qstr%(table,newFieldName,self.ZSQLQuote(normal(getattr(result,fieldname))),result.oid))
110:
111: def importAccessModell(self,configFileName,RESPONSE=None):
112: """import tables from access
113: @param configFileName: xml-configfile
114: """
115: from Ft.Xml import Parse
116: fh=file(configFileName)
117:
118: doc=Parse(fh)
119:
120: x=doc.xpath("//pathToFolder/@path")
121:
122:
123: if not (len(x)==1): # tag ist nich eineindeutig
124: return False
125:
126: pathToFolder=x[0].value
127:
128: for db in doc.xpath("//db"):
129:
130: containers=db.xpath("./@container")
131: identifiers=db.xpath("./@identify")
132:
133:
134: if not (len(containers)==1):
135: return False
136: else:
137: container=containers[0].value
138:
139: if not (len(identifiers)==1):
140: identifier=None
141: else:
142: identifier=identifiers[0].value
143:
144: self.xsdToTable(container.lower(),container,modus="drop",filename=os.path.join(pathToFolder,container.lower()+".xsd"))
145: self.importXMLFileAccess(container.lower(),container,filename=os.path.join(pathToFolder,container.lower()+".xml"),identify=identifier)
146:
147: return "<html><body>DONE</body></html>"
148:
149: def xsdToTable(self,table,elementNameForTable,modus="update", filename=None,data=None,RESPONSE=None):
150: """reads an xsd file an creates the columns of a table out of its structure
151: @param table: name of the table the xml shall be imported into
152: @param elementNameForTable: must be a element of type complex type. the element of the sequence in the complex type
153: define the columns of the table >table<
154: @param data (optional): data to be imported
155:
156: @param filename (optional) or filename
157: @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
158: @param RESPONSE: (optional)
159:
160: """
161: #from xml.dom.minidom import parseString,parse
162:
163: from Ft.Xml import Parse
164: zLOG.LOG("import xsd",zLOG.INFO,"called")
165: #fh=file("/tmp/fmpxml.xml")
166: import bz2
167: import base64
168:
169:
170: ret=""
171: if data:
172: data=bz2.decompress(base64.decodestring(data))
173:
174: #zLOG.LOG("import xsd",zLOG.INFO,"received file")
175: doc=Parse(data)
176: #zLOG.LOG("import xsd",zLOG.INFO,"parsed file")
177:
178: elif filename:
179: fh=file(filename)
180: txt=fh.read()
181:
182: doc=Parse(txt)
183: #zLOG.LOG("import xsd",zLOG.INFO,"parsed file")
184:
185:
186: Nss={'xsd':'http://www.w3.org/2001/XMLSchema'}
187: definingSequence=doc.xpath("""//xsd:element[@name='%s']/xsd:complexType/xsd:sequence/xsd:element/@name"""%elementNameForTable,explicitNss=Nss)
188:
189: fieldNames=[x.value for x in definingSequence]
190:
191:
192:
193: #check if table exists
194:
195: qstr="""select relname from pg_class where relname = '%s'"""%table
196: if not(self.ZSQLSimpleSearch(qstr)) or (len (self.ZSQLSimpleSearch(qstr))<1): # if not the create the table
197: columns=[]
198: create=True
199: else:
200: create=False
201:
202: zLOG.LOG("update xsd: fieldnames",zLOG.INFO,repr(fieldNames))
203: qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s' """
204: columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]
205:
206:
207: if (modus=="drop") and (not create): #table shall be deleted, therefore it should exist (not create)
208: print "drop"
209: qstr="""DROP TABLE %s """
210: self.ZSQLSimpleSearch(qstr%table)
211: columns=[]
212: create=True
213:
214: for fieldName in fieldNames:
215: if type(fieldName) is UnicodeType:
216: fieldName=fieldName.encode('utf-8')
217: zLOG.LOG("update xml: fieldname",zLOG.INFO,repr(fieldName))
218: if fieldName.lower() not in columns:
219:
220: if create:# table does not exist therefore create with one column
221: qstr="""create table %s (%s %s)"""
222: create=False
223: else:# otherwise add the field
224: qstr="""alter table %s add %s %s"""
225:
226: self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
227: zLOG.LOG("update xsd: fieldname add",zLOG.INFO,qstr%(table,fieldName,'text'))
228:
229:
230: def importXMLFileAccess(self,table,container,data=None,identify=None,filename=None,RESPONSE=None):
231: '''
232: Import XML file in access format into the table
233: @param table: name of the table the xml shall be imported into
234: @param containerTagName: XML-Tag which describes a dataset
235: @param data: data to be imported
236: @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
237: @param RESPONSE: (optional)
238: '''
239: from xml.dom.pulldom import parseString,parse
240:
241: zLOG.LOG("import xml",zLOG.INFO,"called")
242: #fh=file("/tmp/fmpxml.xml")
243: import bz2
244: import base64
245:
246: ret=""
247: if data:
248: data=bz2.decompress(base64.decodestring(data))
249:
250: zLOG.LOG("import xml",zLOG.INFO,"received file")
251: doc=parseString(data)
252: zLOG.LOG("import xml",zLOG.INFO,"parsed file")
253:
254: elif filename:
255: fh=file(filename)
256: doc=parse(fh)
257: zLOG.LOG("import xml",zLOG.INFO,"parsed file")
258: while 1:
259: node=doc.getEvent()
260:
261: if node is None:
262: break;
263: else:
264: if node[1].nodeName.lower()==container.lower(): # make everything case insensitive
265: doc.expandNode(node[1])
266:
267: dataSet={}
268: for col in node[1].childNodes:
269: if col.nodeType is col.ELEMENT_NODE:
270: data=col.nodeName
271: dataSet[data]=getTextFromNode(col)
272:
273: update=False
274:
275: if identify:
276:
277: field=dataSet[identify]
278:
279: searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)
280: zLOG.LOG("import xml",zLOG.INFO,searchStr)
281: search=self.ZSQLSimpleSearch(searchStr)
282: if search:
283: update=True
284:
285: if update:
286: tmp=[]
287: for fieldName in dataSet.keys():
288: tmp.append("""%s = %s"""%(fieldName,self.ZSQLQuote(dataSet[fieldName])))
289: setStr=",".join(tmp)
290:
291: field=dataSet[identify]
292:
293: queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)
294: zLOG.LOG("update xml",zLOG.INFO,queryStr)
295: self.ZSQLSimpleSearch(queryStr)
296: ret+="ud: %s \n"%field
297: else:
298:
299:
300: fields=",".join(dataSet.keys())
301: values=",".join([""" %s """%self.ZSQLQuote(dataSet[x]) for x in dataSet.keys()])
302:
303:
304: queryStr="""INSERT INTO %s (%s) VALUES (%s)"""%(table,fields,values)
305: self.ZSQLSimpleSearch(queryStr)
306: zLOG.LOG("update xml",zLOG.INFO,queryStr)
307:
308:
309:
310:
311: return ret
312:
313:
314: def importXMLFile(self,table,data=None,identify=None,filename=None,RESPONSE=None):
315: #TODO: finish importXMLFile
316: '''
317: Import XML file into the table
318: @param table: name of the table the xml shall be imported into
319: @param containerTagName: XML-Tag which describes a dataset
320: @param file: xmlfile handle
321: @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
322: @param RESPONSE: (optional)
323: '''
324: from xml.dom.pulldom import parseString
325:
326: doc=parseString(file.read())
327: while 1:
328: node=doc.getEvent()
329:
330: if node is None:
331: break;
332: else:
333: if node[1].nodeName==containerTagName:
334: doc.expandNode(node[1])
335: cols=node[1].getElementsByTagName('COL')
336: dataSet=[]
337: for col in cols:
338: data=col.getElementsByTagName('DATA')
339: dataSet.append(getTextFromNode(data[0]))
340: update=False
341: if identify:
342:
343: nr=fieldNames.index(identify)
344: field=dataSet[nr]
345:
346: searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)
347: zLOG.LOG("import xml",zLOG.INFO,searchStr)
348: search=self.ZSQLSimpleSearch(searchStr)
349: if search:
350: update=True
351:
352: if update:
353: tmp=[]
354: for fieldName in fieldNames:
355: tmp.append("""%s = %s"""%(fieldName,self.ZSQLQuote(dataSet[fieldNames.index(fieldName)])))
356: setStr=",".join(tmp)
357: nr=fieldNames.index(identify)
358: field=dataSet[nr]
359:
360: queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)
361: zLOG.LOG("update xml",zLOG.INFO,queryStr)
362: self.ZSQLSimpleSearch(queryStr)
363: ret+="ud: %s \n"%field
364: else:
365:
366:
367: fields=",".join(fieldNames)
368: values=",".join([""" %s """%self.ZSQLQuote(x) for x in dataSet])
369:
370:
371: queryStr="""INSERT INTO %s (%s) VALUES (%s)"""%(table,fields,values)
372: self.ZSQLSimpleSearch(queryStr)
373: zLOG.LOG("update xml",zLOG.INFO,queryStr)
374: ret+="ad: %s \n"%field
375:
376: elif node[1].nodeName=="METADATA":
377: fieldNames=[]
378: doc.expandNode(node[1])
379:
380: names=node[1].getElementsByTagName('FIELD')
381:
382: for name in names:
383: fieldNames.append(name.getAttribute('NAME'))
384:
385: zLOG.LOG("update xml: fieldnames",zLOG.INFO,repr(fieldNames))
386: qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s' """
387: columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]
388:
389: for fieldName in fieldNames:
390: zLOG.LOG("update xml: fieldname",zLOG.INFO,repr(fieldName))
391: if fieldName not in columns:
392: qstr="""alter table %s add %s %s"""
393: self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
394: zLOG.LOG("update xml: fieldname add",zLOG.INFO,qstr%(table,fieldName,'text'))
395: #fn=node[1].getAttribute("xml:id")
396: #nf=file("xtf/"+fn+".xtf",'w')
397: #nf.write("""<texts xmlns="http://emegir.info/xtf" xmlns:lem="http://emegir.info/lemma" >"""+node[1].toxml()+"</texts>")
398: #print "wrote: %s"%fn
399:
400:
401: def generateIndex(self,field,index_name,table,RESPONSE=None):
402: """erzeuge index aus feld"""
403: index={}
404: founds=self.ZSQLSimpleSearch("""SELECT %s,oid FROM %s LIMIT 2000"""%(field,table))
405:
406: for found in founds:
407: tmp=getattr(found,field,None)
408: if tmp:
409: strings=tmp.split(" ")
410: for string in strings:
411: if index.get(string):
412: index[string].append(found.oid)
413: else:
414: index[string]=[found.oid]
415: RESPONSE.write(string+"\n")
416:
417: if not hasattr(self,index_name):
418: obj=ZSQLIndex(index,index_name,table)
419: self._setObject(index_name,obj)
420:
421: self._getOb(index_name).setIndex(index)
422:
423: def getIndex(self,index_name):
424: """getIndex"""
425: founds=self.ZopeFind(self,obj_ids=[index_name])
426:
427: return founds[0][1].getIndex()
428:
429:
430: def testneu(self):
431: """test"""
432: relStatement="""period like '%s%%'"""
433: statement="select * from cdli_cat"
434: wherePart="museum_no like 'VAT%'"
435: classes=['Uruk III','Uruk IV']
436: return self.searchRel(relStatement,statement,wherePart,classes)
437:
438: def URLquote(self,txt):
439: """urlquote"""
440: return urllib.quote(txt)
441:
442: def searchRel(self,relStatement,statement,wherePart,classes):
443: """suche relative haufigkeiten"""
444: ret={}
445: allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))
446:
447: for oneclass in classes:
448: ret[oneclass]=len(self.ZSQLSimpleSearch(statement + " where ("+wherePart+") and "+ relStatement%oneclass))
449:
450: return (ret,allRecords)
451:
452: def content_html(self):
453: """template fuer content"""
454:
455: try:
456: obj=getattr(self,"ZSQLBibliography_template")
457: return obj()
458: except:
459: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ZSQLBibliography_template_standard.zpt'),content_type='text/html').__of__(self)
460: pt.content_type="text/html"
461:
462: return pt()
463:
464:
465: def getWeight(self):
466: """getLabe"""
467: try:
468: return self.weight
469: except:
470: return ""
471:
472: def getLabel(self):
473: """getLabe"""
474: try:
475: return self.label
476: except:
477: return ""
478:
479: def getDescription(self):
480: """getLabe"""
481: try:
482: return self.description
483: except:
484: return ""
485:
486: manage_options=Folder.manage_options+(
487: {'label':'Main Config','action':'changeZSQLExtendForm'},
488: )
489:
490: def changeZSQLExtendForm(self):
491: """change folder config"""
492: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeZSQLExtendForm.zpt')).__of__(self)
493: return pt()
494:
495:
496: def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):
497: """change it"""
498: self.connection_id=connection_id
499: self.weight=weight
500: self.label=label
501: self.description=description
502:
503: if REQUEST is not None:
504: return self.manage_main(self, REQUEST)
505:
506: def formatAscii(self,str,url=None):
507: """ersetze ascii umbrueche durch <br>"""
508: #url=None
509: str=str.rstrip().lstrip()
510:
511: if url and str:
512:
513: retStr=""
514: words=str.split("\n")
515:
516: for word in words:
517: strUrl=url%word
518: #print "str",strUrl
519: retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
520: str=retStr
521: if str:
522: return re.sub(r"[\n]","<br/>",str)
523: else:
524: return ""
525:
526: def getSAttribute(self,obj,atribute,pref=''):
527: """get Attribute or emptystring"""
528:
529: #print "obj",obj
530: try:
531: return pref+getattr(obj,atribute)
532: except:
533: return ""
534:
535: def getS(self,str):
536: """make none to empty string"""
537: if str:
538: return str
539: else:
540: return ""
541:
542: def actualPath(self,url=None):
543: """path"""
544:
545: if self.REQUEST['HTTP_X_FORWARDED_SERVER']=='':
546: host=self.REQUEST['HTTP_HOST']
547: else:
548: host=self.REQUEST['HTTP_X_FORWARDED_SERVER']
549: if not url:
550: return "http://"+host+self.REQUEST['PATH_TRANSLATED']
551: else:
552: temp=self.REQUEST[url].split("/")
553: temp[2]=host
554: return string.join(temp,"/")
555:
556: def getRequest(self):
557: """request"""
558: return self.REQUEST
559:
560: def lowerEnd(self,path):
561: """oinly for demo"""
562: return os.path.splitext(path)[0]+".jpg"
563:
564: def ZSQLisEmpty(self,field):
565: """Teste ob Treffer leer"""
566: #print "field",field
567: if not field:
568: return 1
569: if field=="":
570: return 1
571: return 0
572:
573: def ZSQLsearchOptions(self,fieldname=""):
574: """return HTML Fragment with search options"""
575:
576: ret="""<select name="-op_%s">
577: <option value="bw">begins with</option> <!-- begins with / beginnt mit, "Wort*" -->
578: <option value="ew">ends with</option>
579: <option value="ct" selected>contains</option> <!-- contains / enthaellt, "Wort" -->
580: <option value="eq">equals</option> <!-- equals / ist, =Wort -->
581: </select>"""%fieldname
582: return ret
583:
584: def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
585: """generate select options from a cr seperated list"""
586: fields=listField.split("\n")
587: ret=""
588: for field in fields:
589: if checked and (field in checked.split("\n")):
590: ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
591: else:
592: ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
593: return ret
594:
595: def ZSQLSelectionFromSearchList(self,fieldname,results,fieldnameResult,boxType="checkbox",checked=None):
596: """generate select options from a cr seperated list"""
597:
598: ret=""
599: if not results: return ""
600:
601: for result in results:
602: field=getattr(result,fieldnameResult)
603: if field:
604: if checked and (getattr(result,fieldnameResult) in checked.split("\n")):
605: ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
606: else:
607: ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
608: return ret
609:
610:
611: def ZSQLOptionsFromCRList(self,fieldname,listField, multiple='',start=None,startValue=None,size=None,selected=None):
612: """generate select oprions form a cr seperated list"""
613: fields=listField.split("\n")
614: if size:
615: ret="""<select name="%s" %s size="%s" >
616: """%(fieldname,multiple,size)
617:
618: else:
619: ret="""<select name="%s" %s >
620: """%(fieldname,multiple)
621: if start:
622: if start==' ':
623: start=''
624: if not startValue:
625: startValue=start
626:
627: ret+="""<option value="%s" >%s</option>"""%(startValue,start)
628: for field in fields:
629: if selected and (field in selected.split("\n")):
630: ret+="""<option selected value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
631: else:
632: ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
633: ret+="""</select>"""
634: return ret
635:
636: def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None,additionalSelect="",size=None,linelen=None,selected=None):
637: """generate select options form a search list
638: es wird
639: <select name=fieldname mutiple>
640: <option value=startValue>start</option>
641: <option value=result.fieldName>result.fieldValue</option>
642: erzeugt.
643:
644: @parameter fieldname: Name fuer name-wert im select-tag
645: @results results: Resultobject einer SQL-suche
646: @parameter fieldName: Name des Feldes, das als value in den option-tag geschrieben werden soll.
647: @parameter valueName: (optional) Name des Feldes, dass als im option-tag ausgegeben wird, default wert ist valueName=fieldName
648: @start: (optional) falls zusaetzliches option tag erzeugt werden soll, gibt start an was im option tag steht
649: @startValue: gibt den entsprechenden Wert an.
650: """
651: if not valueName:
652: valueName=fieldName
653: if size:
654: ret="""<select name="%s" %s size="%s" %s>
655: """%(fieldname,multiple,size,additionalSelect)
656: else:
657: ret="""<select name="%s" %s %s>
658: """%(fieldname,multiple,additionalSelect)
659: if start:
660: if start==' ':
661: start=''
662:
663: if not startValue:
664: startValue=start
665:
666: ret+="""<option value="%s" >%s</option>"""%(startValue,start)
667: for result in results:
668: field=getattr(result,fieldName)
669: fieldValue=getattr(result,valueName)
670: if fieldValue:
671:
672: if not linelen:
673:
674:
675: if field == selected:
676:
677: ret+="""<option value="%s" selected>%s</option>"""%(field,fieldValue)
678: else:
679: ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
680:
681: else:
682: mist = """%s"""%(fieldValue)
683: if len(mist) > string.atoi(linelen):
684: mist = mist[:string.atoi(linelen)]
685: ret+="""<option value="%s">%s</option>"""%(field,mist)
686: ret+="""</select>"""
687: return ret
688:
689:
690: def ZSQLInlineSearchU(self,storename=None,args=None,**argv):
691: """one element if exists"""
692: qs=[]
693: if storename:
694: """store"""
695: storename=storename
696: else:
697: storename="foundCount"
698:
699: if args:
700: argTmp=args
701: else:
702: argTmp=argv
703:
704:
705: #print "INLINE:",argv
706: for a in argTmp.keys():
707: aFiltered=re.sub(r"^-","_",a) # beginning of a command should always be "_"
708: qs.append(aFiltered+"="+urllib.quote(str(argTmp[a])))
709: #return []
710: ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)
711:
712: try:
713: return ret[0]
714: except:
715: return None
716:
717:
718: def ZSQLSequentialSearch(self,_fieldlist,_searchTerm,storename=None,args=None,**argv):
719: """get a list of tuples (fields,searchoptions,table) to search the searchTerm in, returns dictionary. """
720: #print "do search with:",_fieldlist,_searchTerm,storename,args,argv
721: ret={}
722: if args:
723: argTmp=args
724: else:
725: argTmp=argv
726:
727: for field in _fieldlist:
728:
729: argTmp2=copy.deepcopy(argTmp)
730: argTmp2[field[0]]=_searchTerm
731: argTmp2['_op_'+field[0]]=field[1]
732: argTmp2['_table']=field[2]
733:
734: ret[field[0]]=(self.ZSQLInlineSearch(storename=storename,args=argTmp2),field[3],field[4],field[5],field[6])
735:
736: return ret
737: def ZSQLInlineSearch(self,storename=None,args=None,**argv):
738: """inlinesearch"""
739:
740: qs=[]
741: if storename:
742: """store"""
743: else:
744: storename="foundCount"
745:
746:
747:
748: if args:
749: argTmp=args
750: else:
751: argTmp=argv
752:
753:
754: #print "INLINE:",argv
755: for a in argTmp.keys():
756: aFiltered=re.sub(r"^-","_",a) # beginning of a command should always be "_"
757: qs.append(aFiltered+"="+urllib.quote(str(argTmp[a])))
758:
759:
760: #return []
761:
762: return self.parseQueryString(string.join(qs,","),"_",storename=storename)
763:
764: def ZSQLInlineSearch2(self,query):
765: """inlinesearch"""
766: qs=[]
767:
768: #print "INLINE:",query
769: return self.ZSQLSimpleSearch(query)
770:
771:
772: def ZSQLResetConnection(self):
773: """reset the connectione"""
774: try:
775: self.getConnectionObj().manage_close_connection()
776: except:
777: zLOG.LOG("ZSQLResetConnection",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
778: try:
779: self.getConnectionObj().manage_open_connection()
780: except:
781: zLOG.LOG("ZSQLResetConnection",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
782:
783: def ZSQLSimpleSearch(self,query=None,max_rows=1000000):
784: """simple search"""
785:
786: #print query
787: if not query:
788: query=self.query
789:
790:
791: if (hasattr(self,"_v_searchSQL") and (self._v_searchSQL == None)) or (not hasattr(self,"_v_searchSQL")):
792:
793: self._v_searchSQL=Shared.DC.ZRDB.DA.DA("_v_searchSQL","_v_searchSQL",self.getConnectionObj().getId(),"var","<dtml-var var>")
794:
795: self._v_searchSQL.max_rows_=max_rows
796: try:
797: return self._v_searchSQL.__call__(var=query)
798: except :
799:
800: if sys.exc_info()[0]=="Database Error":
801: try:
802: self.getConnectionObj().manage_open_connection()
803: except:
804: zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
805: else:
806: try:
807:
808: self._v_searchSQL.max_rows_=max_rows
809:
810: return self._v_searchSQL.__call__(var=query)
811: except :
812:
813: if sys.exc_info()[0]=="Database Error":
814: try:
815: self.getConnectionObj().manage_open_connection()
816: except:
817: zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
818:
819: def getConnectionObj(self):
820: if hasattr(self,'connection_id'):
821: return getattr(self,self.connection_id)
822:
823:
824: def ZSQLSimpleSearch2(self,query=None):
825: """ returrn SQLSearch"""
826:
827: if not query:
828: query=self.query
829: if getattr(self,'_v_search',None):
830:
831: return self._v_search(var=query)
832:
833: if hasattr(self,'search') and (self.search.meta_type=="Z SQL Method"):
834: self._v_search=self.search
835: return self.search(var=query)
836: else:
837: if hasattr(self.aq_parent.aq_parent,'search') and (self.aq_parent.aq_parent.search.meta_type=="Z SQL Method"):
838: self._v_search=self.aq_parent.aq_parent.search
839: return self.aq_parent.aq_parent.search(var=query)
840: else:
841: search=self.ZopeFind(self,obj_metatypes=["Z SQL Method"],search_sub=1)
842: if search:
843: self._v_search=search[0][1]
844: return search[0][1](var=query)
845: else:
846: return []
847:
848:
849:
850: def ZSQLAdd(self,format=None,RESPONSE=None,args=None,**argv):
851: """Neuer Eintrag"""
852:
853: if args:
854: argTmp=args
855: else:
856: argTmp=argv
857:
858: qs_temp=[]
859:
860: for a in self.REQUEST.form.keys():
861: qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
862:
863: qs=string.join(qs_temp,",")
864:
865: for field in argTmp.keys():
866: if field[0]=="_":
867: fieldTmp="-"+field[1:]
868: else:
869: fieldTmp=field
870:
871: qs+=",%s=%s"%(fieldTmp,argTmp[field])
872:
873:
874: addList={}
875: for q in qs.split(","):
876: name=re.sub("r'+'"," ",q.split("=")[0].lower())
877: value=q.split("=")[1]
878: value=re.sub(r'\+'," ",value)
879: value=urllib.unquote(value)
880: if name=="-table":
881: table=urllib.unquote(value)
882: elif name=="-format":
883: format=urllib.unquote(value)
884: elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
885: addList[urllib.unquote(name)]=urllib.unquote(value)
886:
887: keyList=[]
888: valueList=[]
889: for x in addList.keys():
890: keyList.append("\""+x+"\"")
891: valueList.append(sql_quote(addList[x]))
892:
893: keyString=string.join(keyList,",")
894: valueString=string.join(valueList,",")
895:
896: queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)
897:
898: self.ZSQLSimpleSearch(queryString)
899:
900: if RESPONSE and format:
901: return RESPONSE.redirect(format)
902: else:
903: return True
904:
905: def ZSQLChange(self,format=None,RESPONSE=None,USE_FORM=None,**argv):
906: """change entries"""
907: #qs=self.REQUEST['QUERY_STRING']
908: # very bad hack
909:
910: qs_temp=[]
911: if USE_FORM or RESPONSE:
912: for a in self.REQUEST.form.keys():
913:
914: qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
915:
916:
917:
918: for field in argv.keys():
919:
920: if field[0]=="_":
921: fieldTmp="-"+field[1:]
922: else:
923: fieldTmp=field
924:
925: qs_temp.append("%s=%s"%(fieldTmp,argv[field]))
926:
927:
928: changeList=[]
929:
930: for q in qs_temp:
931:
932: name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
933: value="=".join(q.split("=")[1:])
934: value=re.sub(r'\+'," ",value)
935: value=urllib.unquote(value)
936:
937: if name=="-table":
938: table=urllib.unquote(value)
939: elif name=="-identify":
940: identify=urllib.unquote(value)
941: identify=identify.split("=")[0]+"="+sql_quote(identify.split("=")[1])
942: elif name=="-format":
943: format=urllib.unquote(value)
944: #elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
945: elif (not (name[0]=="-" or name[0]=="_")):
946:
947: if value=="":
948: changeList.append("\""+name+"\"=null")
949: else:
950: changeList.append("\""+name+"\"="+sql_quote(urllib.unquote(value)))
951:
952: changeString=string.join(changeList,",")
953:
954: queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
955: zLOG.LOG("ZSQLExtend",zLOG.INFO,"CHANGE: "+queryString)
956:
957: self.ZSQLSimpleSearch(queryString)
958:
959:
960: if RESPONSE and format:
961: return RESPONSE.redirect(format)
962: else:
963: return True
964:
965:
966: def ZSQLFindIndexed(self,qs="",select="oid,*",storename=None,indexedFields=['data_line'],restrictField='id_text',**argv):
967: """find2"""
968:
969: for index in self.ZopeFind(self,obj_ids=indexedFields):
970: txt=argv.get(index[0],None)
971: if txt:
972: oids=index[1].getIndex()[txt]
973:
974: search1= self.ZSQLFind(qs=qs,select=select,storename=storename,tableExt=tableList[1],restrictField=restrictField,NoQuery='yes',NoLimit='yes',**argv)
975:
976: search2 = self.ZSQLFind(tableExt=tableList[0],qs=qs,select=select,storename=storename,restrictConnect=(tableList[0]+"."+restrictField,search1),**argv)
977: return search2
978:
979: def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],restrictField='id_text',**argv):
980: """find2"""
981:
982: search1= self.ZSQLFind(qs=qs,select=select,storename=storename,tableExt=tableList[1],restrictField=restrictField,NoQuery='yes',NoLimit='yes',**argv)
983:
984: search2 = self.ZSQLFind(tableExt=tableList[0],qs=qs,select=select,storename=storename,restrictConnect=(tableList[0]+"."+restrictField,search1),**argv)
985: return search2
986:
987:
988:
989: def ZSQLFind(self,qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,**argv):
990: """search in database"""
991:
992: def delEmpty(list):
993: """"loesche leere elemente aus der liste"""
994: ret=[]
995: for x in list:
996: splitted=x.split("=")
997: if (len(splitted)>1) and not (splitted[1]==' '):
998: ret.append(x)
999: return ret
1000:
1001: if qs=="":
1002: #kein querystring ubergeben
1003: if self.REQUEST['QUERY_STRING']:
1004: qs=self.REQUEST['QUERY_STRING']
1005:
1006: qs=string.join(qs.split("&"),",")
1007:
1008: for field in argv.keys():
1009: if field[0]=="_":
1010: fieldTmp="-"+field[1:]
1011: else:
1012: fieldTmp=field
1013:
1014: qs+=",%s=%s"%(fieldTmp,argv[field])
1015:
1016: else:
1017:
1018: qs=self.REQUEST.SESSION.get('query','')
1019:
1020: for field in argv.keys():
1021: if field[0]=="_":
1022: fieldTmp="-"+field[1:]
1023: else:
1024: fieldTmp=field
1025:
1026: qs+=",%s=%s"%(fieldTmp,argv[field])
1027:
1028:
1029:
1030: else:
1031: self.REQUEST['QUERY_STRING']=qs
1032:
1033: qs=string.join(qs.split("&"),",")
1034:
1035:
1036:
1037: qs=re.sub("\\+"," ",qs)#TODO: Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.
1038:
1039: qs=string.join(delEmpty(qs.split(",")),",")
1040:
1041: if storename:
1042: """store"""
1043: else:
1044: storename="foundCount"
1045:
1046: #store query for further usage
1047: self.REQUEST.SESSION['query']=qs
1048:
1049: #print "calling Query with",repr(NoQuery)
1050: ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename,tableExt=tableExt,NoQuery=NoQuery,NoLimit=NoLimit,restrictField=restrictField,restrictConnect=restrictConnect,filter=filter)
1051: #print self.REQUEST.SESSION["foundCount"]
1052:
1053:
1054:
1055: return ret
1056:
1057: def ZSQLFoundCountLen(self,var):
1058: return len(var)
1059:
1060: def ZSQLFoundCount(self,qs="",select="*",storename=None):
1061:
1062: ## if qs=="":
1063:
1064: ## if self.REQUEST['QUERY_STRING']:
1065:
1066: ## qs=self.REQUEST['QUERY_STRING']
1067: ## qs=string.join(qs.split("&"),",")
1068: ## else:
1069:
1070: ## qs=self.REQUEST.SESSION['query']
1071: ## else:
1072: ## qs=string.join(qs.split("&"),",")
1073:
1074:
1075: ## temp= self.parseQueryString(qs,"-",select=select,storemax="yes",nostore="yes")
1076: if storename:
1077: """store"""
1078: else:
1079: storename="foundCount"
1080:
1081: return self.REQUEST.SESSION[storename]['count']
1082:
1083: def ZSQLRangeStart(self,storename=None):
1084:
1085: if storename:
1086: """store"""
1087: else:
1088: storename="foundCount"
1089:
1090: return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
1091:
1092: def ZSQLRangeSize(self,storename=None):
1093:
1094: if storename:
1095: """store"""
1096: else:
1097: storename="foundCount"
1098:
1099: return self.REQUEST.SESSION[storename]['rangeSize']
1100:
1101: def ZSQLRangeEnd(self,storename=None):
1102:
1103: if storename:
1104: """store"""
1105: else:
1106: storename="foundCount"
1107:
1108: return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))
1109:
1110: def ZSQLNewQuery(self,linkText,storename=None,**argv):
1111: """suche neu"""
1112: return self.ZSQLNewSearch(linkText,storename,url=self.REQUEST['URL'],args=argv)
1113:
1114: def ZSQLNewSearch(self,linkText,storename=None,url=None,args=None,**argv):
1115: """suche mit alten parametern bis auf die in argv getauschten"""
1116: str = self.ZSQLNewSearchURL(storename, url, args, **argv)
1117: return """<a href="%s"> %s</a>"""%(str,linkText)
1118:
1119:
1120: def ZSQLNewSearchURL(self, storename=None,url=None,args=None,**argv):
1121: """suche mit alten parametern bis auf die in argv getauschten"""
1122:
1123: if storename:
1124: """store"""
1125: else:
1126: storename="foundCount"
1127: qs=self.REQUEST.SESSION[storename]['qs']
1128:
1129: if args:
1130: argv=args
1131:
1132: querys=qs.split(",")
1133: argList=[]
1134: arg=""
1135: queryList=[x.split("=")[0] for x in querys]
1136:
1137: for argTmp in argv.keys():
1138:
1139:
1140: arg=argTmp[0:]
1141: if arg[0]=="_":arg="-"+argTmp[1:] # aender _ in - als standard
1142:
1143: if arg not in queryList: # noch nicht drin
1144: querys.append("%s=%s"%(arg,argv[argTmp]))
1145: argList.append(arg)
1146:
1147:
1148:
1149: newquery=[]
1150: for query in querys:
1151: queryArg=query.split("=")[0]
1152: qarg=queryArg[0:]
1153: if qarg[0]=="-":qarg="_"+queryArg[1:] # aender _ in - als standard
1154:
1155: if queryArg in argList:
1156: newquery.append("%s=%s"%(queryArg,argv[qarg]))
1157: else:
1158: newquery.append(query)
1159:
1160: if url:
1161: str=url+"?"+"&".join(newquery)
1162: else:
1163: str="ZSQLSearch?"+"&".join(newquery)
1164:
1165: return str
1166:
1167: 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):
1168: """analysieren den QueryString"""
1169:
1170:
1171: #setzte generische werte
1172:
1173: lop="AND" # standardsuche mit and
1174: max="ALL" #standard alle auswaehlen
1175: maxstr=""
1176: whereList=[]
1177: sort=""
1178: op="bw"
1179: opfields={}
1180: lopfields={} #Verknuepfung bei mehrfachauswahl von einem feld
1181: sortfields={} #order of sortfields
1182: diacritics={} #diacritische zeichen, falls "no", dann werden diese fuer das feld gefiltert.
1183: sortAllFields=None
1184: skip=""
1185: rangeStart=0
1186: limit=0
1187: searchFields={}
1188: searchFieldsOnly={}
1189: queryTemplate=[]
1190:
1191: if not select:
1192: select="oid,*"
1193:
1194: #check for op
1195: splitted=qs.split(",")
1196:
1197: if tableExt:
1198: table=tableExt
1199:
1200: if restrictField:
1201: select=restrictField
1202:
1203:
1204: #erster durchgang suche operatoren
1205: for q in splitted:
1206:
1207: name=re.sub("r'+'"," ",q.split("=")[0].lower())
1208: try:
1209: value=urllib.unquote(q.split("=",1)[1])
1210: except:
1211: value=""
1212: #print "Hi",name[0:3],q
1213: if name[0:3]==iCT+"op":
1214: op=value
1215:
1216: field=name[4:]
1217: opfields[field]=op
1218:
1219: if name[0:4]==iCT+"lop":
1220: lop=value
1221:
1222: field=name[5:]
1223: lopfields[field]=lop
1224:
1225: if name[0:11]==iCT+"diacritics":
1226: field=name[12:]
1227: diacritics[field]=value
1228:
1229: if name[0:10]==iCT+"sortorder":
1230: #sort=value
1231:
1232: field=name[11:]
1233: sortAllFields=None
1234: #no field selected
1235: if field=="":
1236: sortAllFields=value
1237: else:
1238: sortfields[field]=value
1239:
1240: #zweiter durchgang analysiere felder
1241: for q in qs.split(","):
1242:
1243:
1244:
1245: name=re.sub("r'+'"," ",q.split("=")[0].lower())
1246: try:
1247: value=urllib.unquote(q.split("=",1)[1])
1248: except:
1249: value=""
1250:
1251: punktsplit=name.split(".") #sonderfall feld mit punkten(tabelle.suchFeld.ausgewaehltesFeld,feldinoriginal), d.h. suche in anderer tabelle:
1252:
1253: #analysiere alle anderen faelle
1254:
1255: if diacritics.get(name,'yes')=='no':
1256: """filter diacritische zeichen"""
1257: value=unicodedata.normalize('NFKD', value.decode('utf-8')).encode('ASCII', 'ignore')
1258:
1259: if name==iCT+"lop":
1260: lop=value
1261: elif name==iCT+"table":
1262: if not tableExt:
1263: table=value
1264: elif name==iCT+"select":
1265: if not restrictField:
1266: select=value
1267: elif name==iCT+"max":
1268: if not NoLimit:
1269: maxstr="LIMIT "+str(value)
1270: limit=str(value)
1271: elif name==iCT+"skip":
1272: skip="OFFSET "+str(value)
1273: rangeStart=str(value)
1274: elif name==iCT+"join":
1275: whereList.append(value)
1276: elif name==iCT+"sort":
1277: sortstrs=[]
1278: for word in value.split(','):
1279: wordstr=word.lstrip().rstrip()
1280: if sortAllFields:
1281: order=sortAllFields
1282: else:
1283: order=sortfields.get(wordstr,'ASC')
1284:
1285: if not (wordstr == ""):
1286: sortstrs.append(wordstr+" "+order)
1287: if len(sortstrs)>0:
1288: sort="ORDER BY "+string.join(sortstrs,',')
1289:
1290:
1291: elif name==iCT+"token":
1292: if not nostore=="yes":
1293: self.REQUEST.SESSION['token']=value
1294:
1295: elif name==iCT+"op":
1296: op=value
1297:
1298:
1299: #sonderfall Name hat das Format:
1300: #TABELLE.SUCHFELD_IN_DIESER_TABELLE.SELECT_FIELD.IDENTIFIER_IN_TABELLE_-table
1301: #i.e. erzeugt wird
1302: #das Statement
1303: #WHERE IDENTIFIER_IN_TABELLE in (select * from SELECT_FIELD
1304: #where LOWER(SUCHFELD_IN_DIESER_TABELLE) something value)
1305: #something is defined by _op_TABELLE.SUCHFELD_IN_DIESER_TABELLE.SELECT_FIELD.IDENTIFIER_IN_TABELLE
1306:
1307: elif (not name[0]==iCT) and len(punktsplit)==4:
1308: if opfields.has_key(name):
1309: op=opfields[name]
1310: else:
1311: op="ct"
1312: namealt=name
1313: name="LOWER("+punktsplit[1]+")"
1314: value=value.lower()
1315: if op=="ct":
1316: tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
1317: elif op=="gt":
1318: tmp=(name+">"+sql_quote(value))
1319: elif op=="lt":
1320: tmp=(name+"<"+sql_quote(value))
1321: elif op=="eq":
1322: tmp=(name+"="+sql_quote(value))
1323: elif op=="bw":
1324: tmp=(name+" LIKE "+sql_quote(value+"%"))
1325: elif op=="ew":
1326: tmp=(name+" LIKE "+sql_quote("%"+value))
1327: elif op=="all":
1328: tmps=[]
1329: for word in value.split(" "):
1330: tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
1331:
1332: tmp=string.join(tmps,' AND ')
1333:
1334: elif op=="numerical":
1335: term=analyseIntSearch(value)
1336: tmp=(name+" "+term)
1337: elif op=="grep":
1338: tmp=(name+" ~* "+sql_quote(value))
1339: elif op=="one":
1340: tmps=[]
1341: for word in value.split(" "):
1342: tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
1343:
1344: tmp=string.join(tmps,' OR ')
1345:
1346: op="all"
1347:
1348:
1349: searchTmp="""%s in (select %s from %s where %s)"""%(punktsplit[3],punktsplit[2],punktsplit[0],tmp)
1350:
1351: queryTemplate.append(searchTmp)
1352:
1353: elif (not name[0]==iCT) and (not len(value)==0):
1354:
1355: #print "OP",op,name
1356: value=value.lower()
1357: tmp=""
1358: if opfields.has_key(name):
1359: op=opfields[name]
1360: else:
1361: op="ct"
1362: namealt=name
1363: name="LOWER("+name+")"
1364: if op=="ct":
1365: tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
1366: elif op=="gt":
1367: tmp=(name+">"+sql_quote(value))
1368: elif op=="lt":
1369: tmp=(name+"<"+sql_quote(value))
1370: elif op=="eq":
1371: tmp=(name+"="+sql_quote(value))
1372: elif op=="bw":
1373: tmp=(name+" LIKE "+sql_quote(value+"%"))
1374: elif op=="ew":
1375: tmp=(name+" LIKE "+sql_quote("%"+value))
1376: elif op=="all":
1377: tmps=[]
1378: for word in value.split(" "):
1379: tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
1380:
1381: tmp=string.join(tmps,' AND ')
1382:
1383: elif op=="numerical":
1384: term=analyseIntSearch(value)
1385: tmp=(name+" "+term)
1386: elif op=="grep":
1387: tmp=(name+" ~* "+sql_quote(value))
1388: elif op=="one":
1389: tmps=[]
1390: for word in value.split(" "):
1391: tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
1392:
1393: tmp=string.join(tmps,' OR ')
1394:
1395: op="all"
1396:
1397: if (not tableExt) or (namealt.split('.')[0]==tableExt):
1398: if searchFields.has_key(namealt):
1399: searchFields[namealt]+=lopfields.get(name,'OR')+" "+tmp
1400: searchFieldsOnly[namealt]+=lopfields.get(name,'OR')+" "+value
1401: else:
1402: searchFields[namealt]=tmp
1403: searchFieldsOnly[namealt]=value
1404:
1405:
1406: whereList=["("+searchFields[x]+")" for x in searchFields.keys()]
1407: whereList+=queryTemplate
1408:
1409: if len(whereList)>0:
1410: if filter:
1411: whereStr="("+string.join(whereList," "+lop+" ")+") AND "+filter
1412: else:
1413: whereStr=string.join(whereList," "+lop+" ")
1414: where="WHERE "+whereStr
1415: else:
1416: if filter:
1417: where="WHERE "+filter
1418: else:
1419: where=""
1420:
1421: if restrictConnect:
1422:
1423: if len(where)==0:
1424: where="WHERE "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
1425: else:
1426: where+="and "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
1427:
1428: #print "QE",table
1429: #print (select,table,where,sort,maxstr,skip)
1430: query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)
1431:
1432: if not nostore=="yes":
1433:
1434: self.REQUEST.SESSION['qs']=opfields
1435: #print "IAMHERE again:", query
1436:
1437: if storename and (not NoQuery):
1438:
1439: query2="SELECT count(*) FROM %s %s"%(table,where)
1440:
1441: #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
1442: if not self.REQUEST.SESSION.has_key(storename):
1443: self.REQUEST.SESSION[storename]={}
1444:
1445: self.REQUEST.SESSION[storename]['qs']=qs #sichere Querystring
1446:
1447: if self.REQUEST.SESSION[storename].has_key('queryString2'):
1448:
1449: if not self.REQUEST.SESSION[storename]['queryString2']==query2:
1450: #print "HOOOOO",storename
1451: self.REQUEST.SESSION[storename]['queryString2']=query2
1452: try:
1453: self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
1454: except:
1455: self.REQUEST.SESSION[storename]['count']=0
1456: #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']
1457:
1458: else:
1459:
1460: self.REQUEST.SESSION[storename]['queryString2']=query2
1461: if self.ZSQLSimpleSearch(query2):
1462: self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
1463: else:
1464: self.REQUEST.SESSION[storename]['count']=0
1465: #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
1466:
1467:
1468: self.REQUEST.SESSION[storename]['rangeStart']=rangeStart
1469: if limit=="all":
1470: self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
1471: else:
1472: self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
1473: self.REQUEST.SESSION[storename]['rangeSize']=limit
1474: self.REQUEST.SESSION[storename]['searchFields']=searchFields
1475:
1476: self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly
1477:
1478: if not NoQuery:
1479:
1480: return self.ZSQLQuery(query)
1481: else:
1482:
1483: return query
1484:
1485: def ZSQLUniqueQuery(self,value,returns):
1486: """unique relation"""
1487: if returns:
1488: statement="""select %s from %s where %s = '%s' """%(returns[1],returns[0],returns[2],value)
1489: founds=self.ZSQLSimpleSearch(statement)
1490: if founds:
1491: return getattr(founds[0],returns[1])
1492: else:
1493: return value
1494: else:
1495: return value
1496:
1497: def ZSQLQuery(self,query,debug=None):
1498: """query"""
1499: if debug:
1500: zLOG.LOG("ZSQLQuery", zLOG.INFO, query)
1501:
1502: return self.ZSQLSimpleSearch(query)
1503:
1504:
1505: def ZSQLSearch(self):
1506: """To be done"""
1507:
1508: formatfile=self.REQUEST['URL1'] #generisch redirect zur gleichen url
1509:
1510: #zerlege querystring in key value paare
1511: #TODO: check if this is really necessary, use argv**
1512:
1513: rq=self.REQUEST['QUERY_STRING']
1514: querys=rq.split("&")
1515: for querytemp in querys: #zerg
1516: query=querytemp.split("=")
1517:
1518: try:
1519: if query[0].lower()=="-format":
1520: formatfile=query[1]
1521: except:
1522: pass
1523:
1524: #sichern
1525: self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
1526: self.REQUEST.SESSION['come_from_search']="yes"
1527:
1528: return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))
1529:
1530:
1531: def ZSQLint(self,string):
1532: try:
1533:
1534: return(int(string))
1535: except:
1536: return 0
1537:
1538: def getZSQLSearchFieldsList(self,storename="foundCount"):
1539: """get searchfieldList"""
1540: #print self.REQUEST.SESSION[storename]['searchFields'].keys()
1541: return self.REQUEST.SESSION[storename]['searchFieldsOnly'].keys()
1542:
1543: def getZSQLSearchFields(self,field,storename="foundCount"):
1544: """get searchfield"""
1545: #print "SF",self.REQUEST.SESSION[storename]['searchFields']
1546:
1547: return self.REQUEST.SESSION[storename]['searchFieldsOnly'][field]
1548:
1549:
1550: def nextLink(self,html,storename="foundCount"):
1551: """nextLink"""
1552:
1553: try:
1554: limit=self.REQUEST.SESSION[storename]['rangeSize']
1555: if int(limit)==0 :
1556: limit="1"
1557: newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)
1558: except:
1559: limit=1
1560: newRangeStart=0
1561:
1562: if newRangeStart>=self.REQUEST.SESSION[storename]['count']:
1563: #newRangeStart=self.REQUEST.SESSION[storename]['count']-1
1564: return ""
1565:
1566: #create new query string
1567:
1568: if self.REQUEST['QUERY_STRING']=="":
1569: qs=self.REQUEST.SESSION['query']
1570:
1571: queries=string.split(qs,",")[0:]
1572:
1573:
1574: else:
1575: qs=self.REQUEST['QUERY_STRING']
1576: queries=string.split(qs,"&")[0:]
1577:
1578:
1579:
1580: newquery=[]
1581:
1582: skipFound=0
1583:
1584: for query in queries:
1585:
1586: if query[0]=="_" : query="-"+query[1:]
1587:
1588: if query.split("=")[0].lower()=="-skip":
1589:
1590: skipFound=1
1591: query="-skip=%i"%newRangeStart
1592: newquery.append(query)
1593:
1594: if skipFound==0 :
1595: query="-skip=%i"%newRangeStart
1596: newquery.append(query)
1597:
1598: newquerystring=string.join(newquery,"&")
1599: return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)
1600:
1601:
1602:
1603: def prevLink(self,html,storename="foundCount"):
1604: """prev link"""
1605:
1606: try:
1607: limit=self.REQUEST.SESSION[storename]['rangeSize']
1608: if int(limit)==0 :
1609: limit="1"
1610: newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])-int(limit)
1611: except:
1612: limit=1
1613: newRangeStart=0
1614: if newRangeStart <0:
1615: return ""
1616:
1617: #print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])
1618:
1619: if newRangeStart<0:
1620: newRangeStart=0
1621:
1622: #create new query string
1623:
1624: if self.REQUEST['QUERY_STRING']=="":
1625: qs=self.REQUEST.SESSION['query']
1626: #qs=re.sub(r'_','-',qs) #aendern fuer query
1627: queries=string.split(qs,",")
1628:
1629:
1630: else:
1631: qs=self.REQUEST['QUERY_STRING']
1632: queries=string.split(qs,"&")
1633:
1634:
1635:
1636: newquery=[]
1637:
1638: skipFound=0
1639:
1640: for query in queries:
1641: #print query.split("=")[0]
1642:
1643: if query[0]=="_" : query[0]="-"
1644:
1645: if query.split("=")[0].lower()=="-skip":
1646: #print"HI"
1647: query="-skip=%i"%newRangeStart
1648: skipFound=1
1649: newquery.append(query)
1650:
1651: if skipFound==0 :
1652: query="-skip=%i"%newRangeStart
1653: newquery.append(query)
1654:
1655: newquerystring=string.join(newquery,"&")
1656:
1657: return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)
1658:
1659:
1660:
1661: def prevLink_old(self,html):
1662: """prev link"""
1663: if self.REQUEST['QUERY_STRING']=="":
1664: qs=self.REQUEST.SESSION['query']
1665: else:
1666: qs=self.REQUEST['QUERY_STRING']
1667: max=re.search(r'max\=(.*)\,',qs.lower())
1668: offset=re.search(r'offset\=(.*)\,',qs.lower())
1669: if not offset:
1670: offsetnew=0
1671: else:
1672: offsetnew=int(offset)-max
1673: if offsetnew<0:
1674: offsetnew=0
1675: queries=string.split(qs,",")
1676: newquery=[]
1677: if offset:
1678: for query in queries:
1679: if query.split("=")[0].lower()=="offset":
1680: query="-offset=%i"%offsetnew
1681: newquery.append(query)
1682: newquerystring=string.join(newquery,"&")
1683: else:
1684: queries.append("-offset=%i"%offsetnew)
1685: newquerystring=string.join(queries,"&")
1686: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
1687:
1688: def nextLink_old(self,html):
1689: """prev link"""
1690: if self.REQUEST['QUERY_STRING']=="":
1691: qs=self.REQUEST.SESSION['query']
1692: else:
1693: qs=self.REQUEST['QUERY_STRING']
1694: max=re.search(r'max\=(.*)\,',qs.lower())
1695:
1696: offset=re.search(r'offset\=(.*)\,',qs.lower())
1697: if not offset:
1698: offsetnew=1
1699: else:
1700: offsetnew=int(offset)+int(max)
1701: if offsetnew<0:
1702: offsetnew=0
1703: queries=string.split(qs,",")
1704: newquery=[]
1705: if offset:
1706: for query in queries:
1707:
1708: if query.split("=")[0].lower()=="-offset":
1709: query="-offset=%i"%offsetnew
1710: newquery.append(query)
1711: newquerystring=string.join(newquery,"&")
1712: else:
1713: queries.append("-offset=%i"%offsetnew)
1714: newquerystring=string.join(queries,"&")
1715:
1716: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
1717:
1718:
1719: manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())
1720:
1721: def manage_addZSQLExtendFolder(self, id, title='', label='', description='',
1722: createPublic=0,
1723: createUserF=0,
1724: connection_id=None,
1725: REQUEST=None):
1726: """Add a new Folder object with id *id*.
1727:
1728: If the 'createPublic' and 'createUserF' parameters are set to any true
1729: value, an 'index_html' and a 'UserFolder' objects are created respectively
1730: in the new folder.
1731: """
1732:
1733:
1734: ob=ZSQLExtendFolder()
1735: ob.id=str(id)
1736: ob.title=title
1737: self._setObject(id, ob)
1738: ob=self._getOb(id)
1739: setattr(ob,'label',label)
1740: setattr(ob,'description',description)
1741: setattr(ob,'connection_id',connection_id)
1742:
1743: checkPermission=getSecurityManager().checkPermission
1744:
1745: if createUserF:
1746: if not checkPermission('Add User Folders', ob):
1747: raise Unauthorized, (
1748: 'You are not authorized to add User Folders.'
1749: )
1750: ob.manage_addUserFolder()
1751:
1752: if createPublic:
1753: if not checkPermission('Add Page Templates', ob):
1754: raise Unauthorized, (
1755: 'You are not authorized to add Page Templates.'
1756: )
1757: ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
1758: id='index_html', title='')
1759:
1760: if REQUEST is not None:
1761: return self.manage_main(self, REQUEST, update_menu=1)
1762:
1763:
1764:
1765: class ZSQLBibliography(Folder,ZSQLExtendFolder):
1766: """Bibliography"""
1767: meta_type="ZSQLBibliography"
1768: def getLabel(self):
1769: try:
1770: return self.label
1771: except:
1772: return ""
1773:
1774: def getDescription(self):
1775: try:
1776: return self.description
1777: except:
1778: return ""
1779:
1780: def changeZSQLBibliographyForm(self):
1781: """change folder config"""
1782: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeZSQLBibliographyForm.zpt')).__of__(self)
1783: return pt()
1784:
1785:
1786: def content_html(self):
1787: """template fuer content"""
1788:
1789: try:
1790: obj=getattr(self,"ZSQLBibliography_template")
1791: return obj()
1792: except:
1793: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ZSQLBibliography_template_standard.zpt')).__of__(self)
1794: pt.content_type="text/html"
1795: return pt()
1796:
1797: def changeZSQLBibliography(self,tableName,label,description,connection_id=None,REQUEST=None):
1798: """change it"""
1799: self.connection_id=connection_id
1800: self.tableName=tableName
1801: self.label=label
1802: self.description=description
1803:
1804: if REQUEST is not None:
1805: return self.manage_main(self, REQUEST)
1806:
1807: manage_options=Folder.manage_options+(
1808: {'label':'Main Config','action':'changeZSQLBibliographyForm'},
1809: {'label':'Generate RDF Template','action':'generateRDFTemplate'},
1810: {'label':'Generate XML Template','action':'generateXMLTemplate'},
1811: )
1812:
1813:
1814: def getFieldLabel(self,fields,field):
1815: """get labels"""
1816: try:
1817: ret =fields[0][field]
1818: if ret == "":
1819: return field
1820: else:
1821: return ret
1822: except:
1823: return field
1824:
1825: def getFieldValue(self,found,field):
1826: """get value"""
1827: try:
1828: ret=getattr(found,field)
1829: if ret == "":
1830: return None
1831: else:
1832: return ret
1833: except:
1834: return None
1835:
1836: def findTagsFromMapping(self,referenceType):
1837: """gib hash mit label -> generic zurueck"""
1838: self.referencetypes=self.ZopeFind(self.standardMD)
1839: bibdata={}
1840: retdata={}
1841: fieldlist=self.standardMD.fieldList
1842:
1843: for referenceTypeF in self.referencetypes:
1844: #print referenceType,referenceTypeF[1].title
1845: if referenceTypeF[1].title == referenceType:
1846: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1847: bibdata['data']=referenceTypeF[1]
1848: self.fields=bibdata[referenceType]
1849: for field in fieldlist:
1850: if referenceTypeF[1].getValue(field)[0]==None:
1851: retdata[field]=field
1852: else:
1853: retdata[field]=referenceTypeF[1].getValue(field)[0]
1854:
1855: return retdata,fieldlist
1856:
1857: def findLabelsFromMapping(self,referenceType):
1858: """gib hash mit label -> generic zurueck"""
1859: self.referencetypes=self.ZopeFind(self.standardMD)
1860: bibdata={}
1861: retdata={}
1862: fieldlist=self.standardMD.fieldList
1863:
1864: for referenceTypeF in self.referencetypes:
1865: #print referenceType,referenceTypeF[1].title
1866: if referenceTypeF[1].title == referenceType:
1867: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1868: bibdata['data']=referenceTypeF[1]
1869: self.fields=bibdata[referenceType]
1870: for field in fieldlist:
1871: retdata[field]=referenceTypeF[1].getValue(field)[1]
1872:
1873: return retdata,fieldlist
1874:
1875: def createRDFTag(self,tag,content,namespace="cdli"):
1876: """create RDF"""
1877: if content:
1878: tag=namespace+":"+tag
1879: if (type(content) is StringType) or (type(content) is UnicodeType):
1880: ret=""" <%s>%s</%s>"""%(tag,escape(content),tag)
1881: else:
1882: ret=""" <%s>%s</%s>"""%(tag,content,tag)
1883: return ret.decode('latin-1')
1884: else:
1885: return ""
1886:
1887: def createIndexTag(self,tag,content):
1888: """create tag"""
1889:
1890: if content:
1891: if (type(content) is StringType) or (type(content) is UnicodeType):
1892: ret=""" <%s>%s</%s>"""%(tag,escape(content),tag)
1893: else:
1894: ret=""" <%s>%s</%s>"""%(tag,content,tag)
1895: return ret.decode('latin-1')
1896:
1897: else:
1898: return ""
1899:
1900: def getXML2(self):
1901: """crate index meta"""
1902:
1903: fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
1904: self.REQUEST['fn']=fn
1905:
1906: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record2.xml')).__of__(self)
1907: pt.content_type="text/xml"
1908: return pt()
1909:
1910:
1911: def generateRDFTemplate(self,REQUEST=None):
1912: """generateRDFtemplate"""
1913: zt=ZopePageTemplate('record.rdf')
1914: self._setObject('record.rdf',zt)
1915: default_content_fn = os.path.join(package_home(globals()),
1916: 'zpt','record.rdf')
1917: text = open(default_content_fn).read()
1918: zt.pt_edit(text, 'text/xml')
1919:
1920:
1921: if REQUEST is not None:
1922: return self.manage_main(self, REQUEST)
1923:
1924: def generateXMLTemplate(self,REQUEST=None):
1925: """generateXMLtemplate"""
1926: zt=ZopePageTemplate('record.xml')
1927: self._setObject('record.xml',zt)
1928: default_content_fn = os.path.join(package_home(globals()),
1929: 'zpt','record.xml')
1930: text = open(default_content_fn).read()
1931: zt.pt_edit(text, 'text/xml')
1932:
1933:
1934: if REQUEST is not None:
1935: return self.manage_main(self, REQUEST)
1936: def getMetaDataRDF(self):
1937: """crate index meta"""
1938: find=self.ZopeFind(self,obj_ids=["record.rdf"])
1939: if not find:
1940: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.rdf')).__of__(self)
1941: pt.content_type="text/xml"
1942: return pt()
1943: else:
1944: return find[0][1]()
1945:
1946: def getMetaDataXML(self):
1947: """crate index meta"""
1948: find=self.ZopeFind(self,obj_ids=["record.xml"])
1949: if not find:
1950: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.xml')).__of__(self)
1951: pt.content_type="text/xml"
1952: return pt()
1953: else:
1954: return find[0][1]()
1955:
1956:
1957: def getMetaDatasXML(self):
1958: """index"""
1959: # check if the request's host part was OK
1960: http_host = self.REQUEST['HTTP_HOST']
1961: host_port = self.REQUEST['SERVER_PORT']
1962: fix_host = None
1963: if http_host and http_host.rfind(host_port) == -1:
1964: #print "HTTP_HOST needs fixing!"
1965: fix_host = http_host + ":" + host_port
1966:
1967: ret="""<?xml version="1.0" ?>
1968: <index>"""
1969: for found in self.ZSQLSimpleSearch("select oid from %s limit ALL"%self.tableName):
1970: base_url = self.absolute_url()
1971: if fix_host:
1972: #print "replacing ", http_host, " by ", fix_host
1973: base_url = string.replace(base_url, http_host, fix_host, 1)
1974:
1975: link=base_url+"/"+"record.html?oid=%i"%found.oid
1976: metalink=base_url+"/"+"getMetaDataXML?oid=%i"%found.oid
1977:
1978: ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)
1979:
1980: return ret+"\n</index>"
1981:
1982:
1983: manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())
1984:
1985: def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
1986: createPublic=0,
1987: createUserF=0,
1988: connection_id=None,
1989: REQUEST=None):
1990: """Add a new Folder object with id *id*.
1991:
1992: If the 'createPublic' and 'createUserF' parameters are set to any true
1993: value, an 'index_html' and a 'UserFolder' objects are created respectively
1994: in the new folder.
1995: """
1996:
1997:
1998: ob=ZSQLBibliography()
1999: ob.id=str(id)
2000: ob.title=title
2001: self._setObject(id, ob)
2002: ob=self._getOb(id)
2003: setattr(ob,'tableName',tableName)
2004: setattr(ob,'label',label)
2005: setattr(ob,'description',description)
2006: setattr(ob,'connection_id',connection_id)
2007:
2008: checkPermission=getSecurityManager().checkPermission
2009:
2010: if createUserF:
2011: if not checkPermission('Add User Folders', ob):
2012: raise Unauthorized, (
2013: 'You are not authorized to add User Folders.'
2014: )
2015: ob.manage_addUserFolder()
2016:
2017: if createPublic:
2018: if not checkPermission('Add Page Templates', ob):
2019: raise Unauthorized, (
2020: 'You are not authorized to add Page Templates.'
2021: )
2022: ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
2023: id='index_html', title='')
2024:
2025: if REQUEST is not None:
2026: return self.manage_main(self, REQUEST, update_menu=1)
2027:
2028:
2029:
2030:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ZSQLExtend.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ZSQLExtend