1: from OFS.Folder import Folder
2: from Globals import Persistent
3: from Acquisition import Implicit
4: from Globals import DTMLFile
5: import urllib
6: import re
7: import string
8: from pyPgSQL import libpq
9: from AccessControl import getSecurityManager
10: import os.path
11: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
12:
13: from Products.ZSQLMethods.SQL import SQLConnectionIDs
14: import Shared.DC.ZRDB.DA
15:
16: def showSQLConnectionIDs(self):
17: return SQLConnectionIDs(self)
18:
19: class ZSQLExtendFolder(Folder,Persistent, Implicit):
20: """Folder"""
21: meta_type="ZSQLExtendFolder"
22:
23: def content_html(self):
24: """template fuer content"""
25:
26: try:
27: obj=getattr(self,"ZSQLBibliography_template")
28: return obj()
29: except:
30: pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt',content_type='text/htm').__of__(self)
31: pt.content_type="text/html"
32:
33: return pt()
34:
35:
36: def getWeight(self):
37: """getLabe"""
38: try:
39: return self.weight
40: except:
41: return ""
42:
43: def getLabel(self):
44: """getLabe"""
45: try:
46: return self.label
47: except:
48: return ""
49:
50: def getDescription(self):
51: """getLabe"""
52: try:
53: return self.description
54: except:
55: return ""
56:
57: manage_options=Folder.manage_options+(
58: {'label':'Main Config','action':'changeZSQLExtendForm'},
59: )
60:
61: def changeZSQLExtendForm(self):
62: """change folder config"""
63: pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLExtendForm.zpt').__of__(self)
64: return pt()
65:
66:
67: def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):
68: """change it"""
69: self.connection_id=connection_id
70: self.weight=weight
71: self.label=label
72: self.description=description
73:
74: if REQUEST is not None:
75: return self.manage_main(self, REQUEST)
76:
77: def formatAscii(self,str,url=None):
78: """ersetze ascii umbrueche durch <br>"""
79: #url=None
80: if url and str:
81:
82: retStr=""
83: words=str.split("\n")
84:
85: for word in words:
86: strUrl=url%word
87: #print "str",strUrl
88: retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
89: str=retStr
90: if str:
91: return re.sub(r"[\n]","<br/>",str)
92: else:
93: return ""
94:
95: def getSAttribute(self,obj,atribute,pref=''):
96: """get Attribute or emptystring"""
97:
98: #print "obj",obj
99: try:
100: return pref+getattr(obj,atribute)
101: except:
102: return ""
103:
104: def getS(self,str):
105: """make none to empty string"""
106: if str:
107: return str
108: else:
109: return ""
110:
111: def actualPath(self,url=None):
112: """path"""
113:
114: if self.REQUEST['HTTP_X_FORWARDED_SERVER']=='':
115: host=self.REQUEST['HTTP_HOST']
116: else:
117: host=self.REQUEST['HTTP_X_FORWARDED_SERVER']
118: if not url:
119: return "http://"+host+self.REQUEST['PATH_TRANSLATED']
120: else:
121: temp=self.REQUEST[url].split("/")
122: temp[2]=host
123: return string.join(temp,"/")
124:
125: def getRequest(self):
126: """request"""
127: return self.REQUEST
128:
129: def lowerEnd(self,path):
130: """oinly for demo"""
131: return os.path.splitext(path)[0]+".jpg"
132:
133: def ZSQLisEmpty(self,field):
134: """Teste ob Treffer leer"""
135: #print "field",field
136: if not field:
137: return 1
138: if field=="":
139: return 1
140: return 0
141:
142: def ZSQLsearchOptions(self,fieldname=""):
143: """return HTML Fragment with search options"""
144:
145: ret="""<select name="-op_%s">
146: <option value="bw">begins with</option> <!-- begins with / beginnt mit, "Wort*" -->
147: <option value="ew">ends with</option>
148: <option value="ct" selected>contains</option> <!-- contains / enthaellt, "Wort" -->
149: <option value="eq">equals</option> <!-- equals / ist, =Wort -->
150: </select>"""%fieldname
151: return ret
152:
153: def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
154: """generate select oprions form a cr seperated list"""
155: fields=listField.split("\n")
156: ret=""
157: for field in fields:
158: if checked and (field in checked.split("\n")):
159: ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
160: else:
161: ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
162: return ret
163:
164:
165: def ZSQLOptionsFromCRList(self,fieldname,listField, multiple=''):
166: """generate select oprions form a cr seperated list"""
167: fields=listField.split("\n")
168: ret="""<select name="%s" %s>
169: """%(fieldname,multiple)
170: for field in fields:
171: ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
172: ret+="""</select>"""
173: return ret
174:
175: def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None):
176: """generate select oprions form a search list seperated list"""
177: if not valueName:
178: valueName=fieldName
179:
180: ret="""<select name="%s" %s>
181: """%(fieldname,multiple)
182: if start:
183: if start==' ':
184: start=''
185: if not startValue:
186: startValue=start
187:
188: ret+="""<option value="%s">%s</option>"""%(startValue,start)
189: for result in results:
190: field=getattr(result,fieldName)
191: fieldValue=getattr(result,valueName)
192: ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
193: ret+="""</select>"""
194: return ret
195:
196:
197: def ZSQLInlineSearchU(self,storename=None,**argv):
198: """one element if exists"""
199: qs=[]
200: if storename:
201: """store"""
202: else:
203: storename="foundCount"
204:
205:
206:
207: #print "INLINE:",argv
208: for a in argv.keys():
209: qs.append(a+"="+urllib.quote(str(argv[a])))
210: #return []
211: ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)
212:
213: try:
214: return ret[0]
215: except:
216: return None
217:
218: def ZSQLInlineSearch(self,storename=None,**argv):
219: """inlinesearch"""
220: qs=[]
221: if storename:
222: """store"""
223: else:
224: storename="foundCount"
225:
226:
227:
228: #print "INLINE:",argv
229: for a in argv.keys():
230: qs.append(a+"="+urllib.quote(str(argv[a])))
231: #return []
232: return self.parseQueryString(string.join(qs,","),"_",storename=storename)
233:
234: def ZSQLInlineSearch2(self,query):
235: """inlinesearch"""
236: qs=[]
237:
238:
239:
240: #print "INLINE:",query
241: return self.ZSQLSimpleSearch(query)
242:
243:
244: def ZSQLSimpleSearch(self,query=None):
245: """ returrn SQLSearch"""
246: if not query:
247: query=self.query
248:
249: if self.search.meta_type=="Z SQL Method":
250: return self.search(var=query)
251: else:
252: if self.aq_parent.aq_parent.search.meta_type=="Z SQL Method":
253: return self.aq_parent.aq_parent.search(var=query)
254: else:
255: return []
256:
257:
258:
259: def ZSQLAdd(self):
260: """Neuer Eintrag"""
261: qs=self.REQUEST['QUERY_STRING']
262: addList={}
263: for q in qs.split("&"):
264: name=re.sub("r'+'"," ",q.split("=")[0].lower())
265: value=q.split("=")[1]
266: value=re.sub(r'\+'," ",value)
267: value=urllib.unquote(value)
268: if name=="-table":
269: table=urllib.unquote(value)
270: elif name=="-format":
271: format=urllib.unquote(value)
272: elif (not name[0]=="-") and (not len(value)==0):
273: addList[urllib.unquote(name)]=urllib.unquote(value)
274:
275: keyList=[]
276: valueList=[]
277: for x in addList.keys():
278: keyList.append("\""+x+"\"")
279: valueList.append(libpq.PgQuoteString(addList[x]))
280:
281: keyString=string.join(keyList,",")
282: valueString=string.join(valueList,",")
283:
284: queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)
285: self.ZSQLSimpleSearch(queryString)
286: return self.REQUEST.RESPONSE.redirect(format)
287:
288: def ZSQLChange(self,**argv):
289: """Ändern von Einträgen"""
290: #qs=self.REQUEST['QUERY_STRING']
291: # very bad hack
292: qs_temp=[]
293:
294: for a in self.REQUEST.form.keys():
295: qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
296:
297: qs=string.join(qs_temp,"&")
298:
299:
300: #print "CHANGE QS",self.REQUEST
301: #return self.REQUEST
302: changeList=[]
303: for q in qs.split("&"):
304: name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
305: value=q.split("=")[1]
306: value=re.sub(r'\+'," ",value)
307: value=urllib.unquote(value)
308: if name=="-table":
309: table=urllib.unquote(value)
310: elif name=="-identify":
311: identify=urllib.unquote(value)
312: identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])
313: elif name=="-format":
314: format=urllib.unquote(value)
315: elif (not name[0]=="-") and (not len(value)==0):
316: changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))
317: changeString=string.join(changeList,",")
318: queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
319: self.ZSQLSimpleSearch(queryString)
320: return self.REQUEST.RESPONSE.redirect(format)
321:
322: def ZSQLChange_old(self):
323: """Ändern von Einträgen"""
324: qs=self.REQUEST['QUERY_STRING']
325: #print "CHANGE QS",self.REQUEST
326: #return self.REQUEST
327: changeList=[]
328: for q in qs.split("&"):
329: name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
330: value=q.split("=")[1]
331: value=re.sub(r'\+'," ",value)
332: value=urllib.unquote(value)
333: if name=="-table":
334: table=urllib.unquote(value)
335: elif name=="-identify":
336: identify=urllib.unquote(value)
337: identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])
338: elif name=="-format":
339: format=urllib.unquote(value)
340: elif (not name[0]=="-") and (not len(value)==0):
341: changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))
342: changeString=string.join(changeList,",")
343: queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
344: self.ZSQLSimpleSearch(queryString)
345: return self.REQUEST.RESPONSE.redirect(format)
346:
347:
348:
349: def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],**argv):
350: """find2"""
351: #search1= self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt='cdli_translit',restrictField='id_text',NoQuery='yes',NoLimit='yes',**argv)
352:
353:
354: #search2 = self.ZSQLFind(tableExt='cdli_cat',qs="",select="oid,*",storename=None,restrictConnect=('cdli_cat.id_text',search1),**argv)
355:
356: search1= self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt='cdli_cat',restrictField='id_text',NoQuery='yes',NoLimit='yes',**argv)
357:
358: search2 = self.ZSQLFind(tableExt='cdli_translit',qs="",select="oid,*",storename=None,restrictConnect=('cdli_translit.id_text',search1),**argv)
359: return search2
360:
361: #return self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,**argv)
362:
363: def ZSQLFind(self,qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,**argv):
364: """Find"""
365:
366: def delEmpty(list):
367: ret=[]
368: for x in list:
369: splitted=x.split("=")
370: if (len(splitted)>1) and not (splitted[1]==' '):
371: ret.append(x)
372: return ret
373:
374: #self.REQUEST.SESSION['come_from_search']="no" # zurücksetzen
375: if qs=="":
376: print "HI"
377: if self.REQUEST['QUERY_STRING']:
378: qs=self.REQUEST['QUERY_STRING']
379:
380:
381: qs=string.join(qs.split("&"),",")
382:
383: for field in argv.keys():
384:
385: qs+=",-%s=%s"%(field,argv[field])
386:
387: else:
388:
389: qs=self.REQUEST.SESSION.get('query','')
390: print "QS:",qs
391: for field in argv.keys():
392: #print field
393: qs+=",-%s=%s"%(field,argv[field])
394:
395: else:
396: self.REQUEST['QUERY_STRING']=qs
397:
398: qs=string.join(qs.split("&"),",")
399:
400:
401:
402: qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.
403:
404: qs=string.join(delEmpty(qs.split(",")),",")
405:
406: if storename:
407: """store"""
408: else:
409: storename="foundCount"
410:
411:
412: print "calling Query with",repr(NoQuery)
413: ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename,tableExt=tableExt,NoQuery=NoQuery,NoLimit=NoLimit,restrictField=restrictField,restrictConnect=restrictConnect)
414: #print self.REQUEST.SESSION["foundCount"]
415:
416: print "called query"
417: return ret
418:
419: def ZSQLFoundCountLen(self,var):
420: return len(var)
421:
422: def ZSQLFoundCount(self,qs="",select="*",storename=None):
423:
424: ## if qs=="":
425:
426: ## if self.REQUEST['QUERY_STRING']:
427:
428: ## qs=self.REQUEST['QUERY_STRING']
429: ## qs=string.join(qs.split("&"),",")
430: ## else:
431:
432: ## qs=self.REQUEST.SESSION['query']
433: ## else:
434: ## qs=string.join(qs.split("&"),",")
435:
436:
437: ## temp= self.parseQueryString(qs,"-",select=select,storemax="yes",nostore="yes")
438: if storename:
439: """store"""
440: else:
441: storename="foundCount"
442:
443: return self.REQUEST.SESSION[storename]['count']
444:
445: def ZSQLRangeStart(self,storename=None):
446:
447: if storename:
448: """store"""
449: else:
450: storename="foundCount"
451:
452: return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
453:
454: def ZSQLRangeSize(self,storename=None):
455:
456: if storename:
457: """store"""
458: else:
459: storename="foundCount"
460:
461: return self.REQUEST.SESSION[storename]['rangeSize']
462:
463: def ZSQLRangeEnd(self,storename=None):
464:
465: if storename:
466: """store"""
467: else:
468: storename="foundCount"
469:
470: return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))
471:
472: def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None):
473: """analysieren den QueryString"""
474: #print "NO",nostore
475: lop="AND" # standardsuche mit and
476: max="ALL" #standard alle auswählen
477: maxstr=""
478: whereList=[]
479: sort=""
480: op="bw"
481: opfields={}
482: lopfields={} #Verknüpfung bei mehrfachauswahl von einem feld
483: skip=""
484: rangeStart=0
485: limit=0
486: searchFields={}
487: searchFieldsOnly={}
488: if not select:
489: select="oid,*"
490: #print "Q",nostore,qs
491: #check for op
492:
493: splitted=qs.split(",")
494: if tableExt:
495: table=tableExt
496:
497: if restrictField:
498: select=restrictField
499:
500: for q in splitted:
501:
502: name=re.sub("r'+'"," ",q.split("=")[0].lower())
503: try:
504: value=urllib.unquote(q.split("=",1)[1])
505: except:
506: value=""
507: #print "Hi",name[0:3],q
508: if name[0:3]==iCT+"op":
509: op=value
510:
511: field=name[4:]
512: opfields[field]=op
513:
514: if name[0:4]==iCT+"lop":
515: lop=value
516:
517: field=name[5:]
518: lopfields[field]=lop
519: #print "HI",op,field
520: #print opfieldsa
521: #now analyse the querystring
522: for q in qs.split(","):
523:
524:
525: #try:
526:
527: name=re.sub("r'+'"," ",q.split("=")[0].lower())
528: try:
529: value=urllib.unquote(q.split("=",1)[1])
530: except:
531: value=""
532:
533: #value=libpq.PgQuoteString(value)
534:
535:
536: if name==iCT+"lop":
537: lop=value
538: elif name==iCT+"table":
539: if not tableExt:
540: table=value
541: elif name==iCT+"select":
542: if not restrictField:
543: select=value
544: elif name==iCT+"max":
545: if not NoLimit:
546: maxstr="LIMIT "+str(value)
547: limit=str(value)
548: elif name==iCT+"skip":
549: skip="OFFSET "+str(value)
550: rangeStart=str(value)
551: elif name==iCT+"join":
552: whereList.append(value)
553: elif name==iCT+"sort":
554: sort="ORDER BY "+value.replace(' AND ',',')
555: elif name==iCT+"token":
556: if not nostore=="yes":
557: self.REQUEST.SESSION['token']=value
558:
559: elif name==iCT+"op":
560: op=value
561:
562:
563:
564: elif (not name[0]==iCT) and (not len(value)==0):
565:
566: #print "OP",op,name
567: value=value.lower()
568: tmp=""
569: if opfields.has_key(name):
570: op=opfields[name]
571: else:
572: op="ct"
573: namealt=name
574: name="LOWER("+name+")"
575: if op=="ct":
576: tmp=(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))
577: elif op=="gt":
578: tmp=(name+">"+libpq.PgQuoteString(value))
579: elif op=="lt":
580: tmp=(name+"<"+libpq.PgQuoteString(value))
581: elif op=="eq":
582: tmp=(name+"="+libpq.PgQuoteString(value))
583: elif op=="bw":
584: tmp=(name+" LIKE "+libpq.PgQuoteString(value+"%"))
585: elif op=="ew":
586: tmp=(name+" LIKE "+libpq.PgQuoteString("%"+value))
587: op="ct"
588: print "TTT",tableExt
589: if (not tableExt) or (namealt.split('.')[0]==tableExt):
590: if searchFields.has_key(name):
591: searchFields[name]+=lopfields.get(name,'OR')+" "+tmp
592: searchFieldsOnly[name]+=lopfields.get(name,'OR')+" "+value
593: else:
594: searchFields[name]=tmp
595: searchFieldsOnly[name]=value
596:
597:
598: ## for name in searchFields.keys():
599: ## value=searchFields[name]
600:
601: ## if opfields.has_key(name):
602: ## op=opfields[name]
603: ## else:
604: ## op="ct"
605: ## name="LOWER("+name+")"
606: ## if op=="ct":
607: ## whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))
608: ## elif op=="gt":
609: ## whereList.append(name+">"+libpq.PgQuoteString(value))
610: ## elif op=="lt":
611: ## whereList.append(name+"<"+libpq.PgQuoteString(value))
612: ## elif op=="eq":
613: ## whereList.append(name+"="+libpq.PgQuoteString(value))
614: ## elif op=="bw":
615: ## whereList.append(name+" LIKE "+libpq.PgQuoteString(value+"%"))
616: ## elif op=="ew":
617: ## whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value))
618: ## op="ct"
619:
620: ## #except:
621: ## # print "END",value,name,Exception
622:
623: whereList=["("+searchFields[x]+")" for x in searchFields.keys()]
624:
625: if len(whereList)>0:
626:
627: where="WHERE "+string.join(whereList," "+lop+" ")
628: else:
629: where=""
630:
631: if restrictConnect:
632: print "resticted"
633: if len(where)==0:
634: where="WHERE "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
635: else:
636: where+="and "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
637:
638: #print "QE",table
639:
640: query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)
641:
642: if not nostore=="yes":
643:
644: self.REQUEST.SESSION['qs']=opfields
645: #print "IAMHERE again:", query
646:
647: if storename and (not NoQuery):
648: query2="SELECT count(*) FROM %s %s"%(table,where)
649: print "storing",query2
650: #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
651: if not self.REQUEST.SESSION.has_key(storename):
652: self.REQUEST.SESSION[storename]={}
653: if self.REQUEST.SESSION[storename].has_key('queryString2'):
654: print "HI",storename
655: if not self.REQUEST.SESSION[storename]['queryString2']==query2:
656: #print "HOOOOO",storename
657: self.REQUEST.SESSION[storename]['queryString2']=query2
658: self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
659:
660: #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']
661:
662: else:
663: print "go"
664: self.REQUEST.SESSION[storename]['queryString2']=query2
665: self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
666: #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
667:
668:
669: self.REQUEST.SESSION[storename]['rangeStart']=rangeStart
670: if limit=="all":
671: self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
672: else:
673: self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
674: self.REQUEST.SESSION[storename]['rangeSize']=limit
675: self.REQUEST.SESSION[storename]['searchFields']=searchFields
676: self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly
677:
678: if not NoQuery:
679: print "noquery",query
680: return self.ZSQLQuery(query)
681: else:
682: print "query"
683: return query
684:
685: def ZSQLQuery(self,query):
686: """query"""
687: return self.ZSQLSimpleSearch(query)
688:
689: def ZSQLSearch(self):
690: """To be done"""
691: rq=self.REQUEST['QUERY_STRING']
692: querys=rq.split("&")
693:
694:
695: for querytemp in querys:
696: query=querytemp.split("=")
697: try:
698: if query[0].lower()=="-format":
699: formatfile=query[1]
700: except:
701: """nothing"""
702: #print formatfile
703:
704: self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
705: self.REQUEST.SESSION['come_from_search']="yes"
706:
707: return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))
708:
709:
710: def ZSQLint(self,string):
711: try:
712:
713: return(int(string))
714: except:
715: return 0
716:
717: def getZSQLSearchFieldsList(self,storename="foundCount"):
718: """get searchfieldList"""
719: #print self.REQUEST.SESSION[storename]['searchFields'].keys()
720: return self.REQUEST.SESSION[storename]['searchFieldsOnly'].keys()
721:
722: def getZSQLSearchFields(self,field,storename="foundCount"):
723: """get searchfield"""
724: #print "SF",self.REQUEST.SESSION[storename]['searchFields']
725:
726: return self.REQUEST.SESSION[storename]['searchFieldsOnly'][field]
727:
728:
729: def nextLink(self,html,storename="foundCount"):
730: """nextLink"""
731: try:
732: limit=self.REQUEST.SESSION[storename]['rangeSize']
733: if int(limit)==0 :
734: limit="1"
735: newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)
736: except:
737: limit=1
738: newRangeStart=0
739:
740: if newRangeStart>=self.REQUEST.SESSION[storename]['count']:
741: #newRangeStart=self.REQUEST.SESSION[storename]['count']-1
742: return ""
743:
744: #create new query string
745:
746: if self.REQUEST['QUERY_STRING']=="":
747: qs=self.REQUEST.SESSION['query']
748:
749: queries=string.split(qs,",")
750:
751:
752: else:
753: qs=self.REQUEST['QUERY_STRING']
754: queries=string.split(qs,"&")
755:
756:
757:
758: newquery=[]
759:
760: skipFound=0
761:
762: for query in queries:
763:
764: #print query.split("=")[0]
765: if query[0]=="_" : query[0]="-"
766:
767: if query.split("=")[0].lower()=="-skip":
768:
769: skipFound=1
770: query="-skip=%i"%newRangeStart
771: newquery.append(query)
772:
773: if skipFound==0 :
774: query="-skip=%i"%newRangeStart
775: newquery.append(query)
776:
777: newquerystring=string.join(newquery,"&")
778:
779: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
780:
781:
782: def prevLink(self,html,storename="foundCount"):
783: """prev link"""
784: try:
785: limit=self.REQUEST.SESSION[storename]['rangeSize']
786: if int(limit)==0 :
787: limit="1"
788: newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])-int(limit)
789: except:
790: limit=1
791: newRangeStart=0
792: if newRangeStart <0:
793: return ""
794:
795: #print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])
796:
797: if newRangeStart<0:
798: newRangeStart=0
799:
800: #create new query string
801:
802: if self.REQUEST['QUERY_STRING']=="":
803: qs=self.REQUEST.SESSION['query']
804: #qs=re.sub(r'_','-',qs) #aendern für query
805: queries=string.split(qs,",")
806:
807:
808: else:
809: qs=self.REQUEST['QUERY_STRING']
810: queries=string.split(qs,"&")
811:
812:
813:
814: newquery=[]
815:
816: skipFound=0
817:
818: for query in queries:
819: #print query.split("=")[0]
820:
821: if query[0]=="_" : query[0]="-"
822:
823: if query.split("=")[0].lower()=="-skip":
824: #print"HI"
825: query="-skip=%i"%newRangeStart
826: skipFound=1
827: newquery.append(query)
828:
829: if skipFound==0 :
830: query="-skip=%i"%newRangeStart
831: newquery.append(query)
832:
833: newquerystring=string.join(newquery,"&")
834:
835: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
836:
837:
838:
839: def prevLink_old(self,html):
840: """prev link"""
841: if self.REQUEST['QUERY_STRING']=="":
842: qs=self.REQUEST.SESSION['query']
843: else:
844: qs=self.REQUEST['QUERY_STRING']
845: max=re.search(r'max\=(.*)\,',qs.lower())
846: offset=re.search(r'offset\=(.*)\,',qs.lower())
847: if not offset:
848: offsetnew=0
849: else:
850: offsetnew=int(offset)-max
851: if offsetnew<0:
852: offsetnew=0
853: queries=string.split(qs,",")
854: newquery=[]
855: if offset:
856: for query in queries:
857: if query.split("=")[0].lower()=="offset":
858: query="-offset=%i"%offsetnew
859: newquery.append(query)
860: newquerystring=string.join(newquery,"&")
861: else:
862: queries.append("-offset=%i"%offsetnew)
863: newquerystring=string.join(queries,"&")
864: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
865:
866: def nextLink_old(self,html):
867: """prev link"""
868: if self.REQUEST['QUERY_STRING']=="":
869: qs=self.REQUEST.SESSION['query']
870: else:
871: qs=self.REQUEST['QUERY_STRING']
872: max=re.search(r'max\=(.*)\,',qs.lower())
873:
874: offset=re.search(r'offset\=(.*)\,',qs.lower())
875: if not offset:
876: offsetnew=1
877: else:
878: offsetnew=int(offset)+int(max)
879: if offsetnew<0:
880: offsetnew=0
881: queries=string.split(qs,",")
882: newquery=[]
883: if offset:
884: for query in queries:
885:
886: if query.split("=")[0].lower()=="-offset":
887: query="-offset=%i"%offsetnew
888: newquery.append(query)
889: newquerystring=string.join(newquery,"&")
890: else:
891: queries.append("-offset=%i"%offsetnew)
892: newquerystring=string.join(queries,"&")
893:
894: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
895:
896:
897: manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())
898:
899: def manage_addZSQLExtendFolder(self, id, title='', label='', description='',
900: createPublic=0,
901: createUserF=0,
902: connection_id=None,
903: REQUEST=None):
904: """Add a new Folder object with id *id*.
905:
906: If the 'createPublic' and 'createUserF' parameters are set to any true
907: value, an 'index_html' and a 'UserFolder' objects are created respectively
908: in the new folder.
909: """
910:
911:
912: ob=ZSQLExtendFolder()
913: ob.id=str(id)
914: ob.title=title
915: self._setObject(id, ob)
916: ob=self._getOb(id)
917: setattr(ob,'label',label)
918: setattr(ob,'description',description)
919: setattr(ob,'connection_id',connection_id)
920:
921: checkPermission=getSecurityManager().checkPermission
922:
923: if createUserF:
924: if not checkPermission('Add User Folders', ob):
925: raise Unauthorized, (
926: 'You are not authorized to add User Folders.'
927: )
928: ob.manage_addUserFolder()
929:
930: if createPublic:
931: if not checkPermission('Add Page Templates', ob):
932: raise Unauthorized, (
933: 'You are not authorized to add Page Templates.'
934: )
935: ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
936: id='index_html', title='')
937:
938: if REQUEST is not None:
939: return self.manage_main(self, REQUEST, update_menu=1)
940:
941:
942:
943: class ZSQLBibliography(Folder,ZSQLExtendFolder):
944: """Bibliography"""
945: meta_type="ZSQLBibliography"
946: def getLabel(self):
947: try:
948: return self.label
949: except:
950: return ""
951:
952: def getDescription(self):
953: try:
954: return self.description
955: except:
956: return ""
957:
958: def changeZSQLBibliographyForm(self):
959: """change folder config"""
960: pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLBibliographyForm.zpt').__of__(self)
961: return pt()
962:
963:
964: def content_html(self):
965: """template fuer content"""
966:
967: try:
968: obj=getattr(self,"ZSQLBibliography_template")
969: return obj()
970: except:
971: pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt').__of__(self)
972: pt.content_type="text/html"
973: return pt()
974:
975: def changeZSQLBibliography(self,tableName,label,description,REQUEST=None):
976: """change it"""
977: self.tableName=tableName
978: self.label=label
979: self.description=description
980:
981: if REQUEST is not None:
982: return self.manage_main(self, REQUEST)
983:
984: manage_options=Folder.manage_options+(
985: {'label':'Main Config','action':'changeZSQLBibliographyForm'},
986: )
987:
988:
989: def getFieldLabel(self,fields,field):
990: """get labels"""
991: try:
992: ret =fields[0][field]
993: if ret == "":
994: return field
995: else:
996: return ret
997: except:
998: return field
999:
1000: def getFieldValue(self,found,field):
1001: """get value"""
1002: try:
1003: ret=getattr(found,field)
1004: if ret == "":
1005: return None
1006: else:
1007: return ret
1008: except:
1009: return None
1010:
1011: def findTagsFromMapping(self,referenceType):
1012: """gib hash mit label -> generic zurueck"""
1013: self.referencetypes=self.ZopeFind(self.standardMD)
1014: bibdata={}
1015: retdata={}
1016: fieldlist=self.standardMD.fieldList
1017:
1018: for referenceTypeF in self.referencetypes:
1019: #print referenceType,referenceTypeF[1].title
1020: if referenceTypeF[1].title == referenceType:
1021: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1022: bibdata['data']=referenceTypeF[1]
1023: self.fields=bibdata[referenceType]
1024: for field in fieldlist:
1025: if referenceTypeF[1].getValue(field)[0]==None:
1026: retdata[field]=field
1027: else:
1028: retdata[field]=referenceTypeF[1].getValue(field)[0]
1029:
1030: return retdata,fieldlist
1031:
1032: def findLabelsFromMapping(self,referenceType):
1033: """gib hash mit label -> generic zurueck"""
1034: self.referencetypes=self.ZopeFind(self.standardMD)
1035: bibdata={}
1036: retdata={}
1037: fieldlist=self.standardMD.fieldList
1038:
1039: for referenceTypeF in self.referencetypes:
1040: #print referenceType,referenceTypeF[1].title
1041: if referenceTypeF[1].title == referenceType:
1042: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1043: bibdata['data']=referenceTypeF[1]
1044: self.fields=bibdata[referenceType]
1045: for field in fieldlist:
1046: retdata[field]=referenceTypeF[1].getValue(field)[1]
1047:
1048: return retdata,fieldlist
1049:
1050: def createIndexTag(self,tag,content):
1051: """creste tag"""
1052: if content:
1053: ret="""<%s>%s</%s>"""%(tag,content,tag)
1054: return ret
1055: else:
1056: return ""
1057:
1058: def getMetaDataXML2(self):
1059: """crate index meta"""
1060:
1061: fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
1062: self.REQUEST['fn']=fn
1063:
1064: pt=PageTemplateFile('Products/ZSQLExtend/zpt/record2.xml').__of__(self)
1065: pt.content_type="text/xml"
1066: return pt()
1067:
1068: def getMetaDataXML(self):
1069: """crate index meta"""
1070: pt=PageTemplateFile('Products/ZSQLExtend/zpt/record.xml').__of__(self)
1071: pt.content_type="text/xml"
1072: return pt()
1073:
1074: def getMetaDatasXML(self):
1075: """index"""
1076: ret="""<?xml version="1.0" ?>
1077: <index>"""
1078: for found in self.ZSQLSimpleSearch("select oid from %s limit ALL"%self.tableName):
1079: link=self.absolute_url()+"/"+"record.html?oid=%i"%found.oid
1080: metalink=self.absolute_url()+"/"+"getMetaDataXML?oid=%i"%found.oid
1081:
1082: ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)
1083:
1084: return ret+"\n</index>"
1085:
1086:
1087: manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())
1088:
1089: def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
1090: createPublic=0,
1091: createUserF=0,
1092: REQUEST=None):
1093: """Add a new Folder object with id *id*.
1094:
1095: If the 'createPublic' and 'createUserF' parameters are set to any true
1096: value, an 'index_html' and a 'UserFolder' objects are created respectively
1097: in the new folder.
1098: """
1099:
1100:
1101: ob=ZSQLBibliography()
1102: ob.id=str(id)
1103: ob.title=title
1104: self._setObject(id, ob)
1105: ob=self._getOb(id)
1106: setattr(ob,'tableName',tableName)
1107: setattr(ob,'label',label)
1108: setattr(ob,'description',description)
1109:
1110: checkPermission=getSecurityManager().checkPermission
1111:
1112: if createUserF:
1113: if not checkPermission('Add User Folders', ob):
1114: raise Unauthorized, (
1115: 'You are not authorized to add User Folders.'
1116: )
1117: ob.manage_addUserFolder()
1118:
1119: if createPublic:
1120: if not checkPermission('Add Page Templates', ob):
1121: raise Unauthorized, (
1122: 'You are not authorized to add Page Templates.'
1123: )
1124: ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
1125: id='index_html', title='')
1126:
1127: if REQUEST is not None:
1128: return self.manage_main(self, REQUEST, update_menu=1)
1129:
1130:
1131:
1132:
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