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