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):
166: """generate select oprions form a cr seperated list"""
167: fields=listField.split("\n")
168: ret="""<select name="%s">
169: """%fieldname
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):
176: """generate select oprions form a cr seperated list"""
177: if not valueName:
178: valueName=fieldName
179:
180: ret="""<select name="%s">
181: """%fieldname
182: if start:
183: if start==' ':
184: start=''
185: ret+="""<option value="%s">%s</option>"""%(start,start)
186: for result in results:
187: field=getattr(result,fieldName)
188: fieldValue=getattr(result,valueName)
189: ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
190: ret+="""</select>"""
191: return ret
192:
193:
194: def ZSQLInlineSearchU(self,storename=None,**argv):
195: """one element if exists"""
196: qs=[]
197: if storename:
198: """store"""
199: else:
200: storename="foundCount"
201:
202:
203:
204: #print "INLINE:",argv
205: for a in argv.keys():
206: qs.append(a+"="+urllib.quote(str(argv[a])))
207: #return []
208: ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)
209:
210: try:
211: return ret[0]
212: except:
213: return None
214:
215: def ZSQLInlineSearch(self,storename=None,**argv):
216: """inlinesearch"""
217: qs=[]
218: if storename:
219: """store"""
220: else:
221: storename="foundCount"
222:
223:
224:
225: #print "INLINE:",argv
226: for a in argv.keys():
227: qs.append(a+"="+urllib.quote(str(argv[a])))
228: #return []
229: return self.parseQueryString(string.join(qs,","),"_",storename=storename)
230:
231: def ZSQLInlineSearch2(self,query):
232: """inlinesearch"""
233: qs=[]
234:
235:
236:
237: #print "INLINE:",query
238: return self.ZSQLSimpleSearch(var=query)
239:
240:
241: def ZSQLSimpleSearch(self,query=None):
242: """ returrn SQLSearch"""
243: if not query:
244: query=self.query
245:
246: if self.search.meta_type=="Z SQL Method":
247: return self.search(var=query)
248: else:
249: if self.aq_parent.aq_parent.search.meta_type=="Z SQL Method":
250: return self.aq_parent.aq_parent.search(var=query)
251: else:
252: return []
253:
254:
255:
256: def ZSQLAdd(self):
257: """Neuer Eintrag"""
258: qs=self.REQUEST['QUERY_STRING']
259: addList={}
260: for q in qs.split("&"):
261: name=re.sub("r'+'"," ",q.split("=")[0].lower())
262: value=q.split("=")[1]
263: value=re.sub(r'\+'," ",value)
264: value=urllib.unquote(value)
265: if name=="-table":
266: table=urllib.unquote(value)
267: elif name=="-format":
268: format=urllib.unquote(value)
269: elif (not name[0]=="-") and (not len(value)==0):
270: addList[urllib.unquote(name)]=urllib.unquote(value)
271:
272: keyList=[]
273: valueList=[]
274: for x in addList.keys():
275: keyList.append("\""+x+"\"")
276: valueList.append(libpq.PgQuoteString(addList[x]))
277:
278: keyString=string.join(keyList,",")
279: valueString=string.join(valueList,",")
280:
281: queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)
282: self.ZSQLSimpleSearch(var=queryString)
283: return self.REQUEST.RESPONSE.redirect(format)
284:
285: def ZSQLChange(self,**argv):
286: """Ändern von Einträgen"""
287: #qs=self.REQUEST['QUERY_STRING']
288: # very bad hack
289: qs_temp=[]
290:
291: for a in self.REQUEST.form.keys():
292: qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
293:
294: qs=string.join(qs_temp,"&")
295:
296:
297: #print "CHANGE QS",self.REQUEST
298: #return self.REQUEST
299: changeList=[]
300: for q in qs.split("&"):
301: name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
302: value=q.split("=")[1]
303: value=re.sub(r'\+'," ",value)
304: value=urllib.unquote(value)
305: if name=="-table":
306: table=urllib.unquote(value)
307: elif name=="-identify":
308: identify=urllib.unquote(value)
309: identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])
310: elif name=="-format":
311: format=urllib.unquote(value)
312: elif (not name[0]=="-") and (not len(value)==0):
313: changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))
314: changeString=string.join(changeList,",")
315: queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
316: self.ZSQLSimpleSearch(var=queryString)
317: return self.REQUEST.RESPONSE.redirect(format)
318:
319: def ZSQLChange_old(self):
320: """Ändern von Einträgen"""
321: qs=self.REQUEST['QUERY_STRING']
322: #print "CHANGE QS",self.REQUEST
323: #return self.REQUEST
324: changeList=[]
325: for q in qs.split("&"):
326: name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
327: value=q.split("=")[1]
328: value=re.sub(r'\+'," ",value)
329: value=urllib.unquote(value)
330: if name=="-table":
331: table=urllib.unquote(value)
332: elif name=="-identify":
333: identify=urllib.unquote(value)
334: identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])
335: elif name=="-format":
336: format=urllib.unquote(value)
337: elif (not name[0]=="-") and (not len(value)==0):
338: changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))
339: changeString=string.join(changeList,",")
340: queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
341: self.ZSQLSimpleSearch(var=queryString)
342: return self.REQUEST.RESPONSE.redirect(format)
343:
344: def ZSQLFind(self,qs="",select="oid,*",storename=None,**argv):
345: """Find"""
346:
347: def delEmpty(list):
348: ret=[]
349: for x in list:
350: splitted=x.split("=")
351: if (len(splitted)>1) and not (splitted[1]==' '):
352: ret.append(x)
353: return ret
354:
355: if qs=="":
356: if self.REQUEST['QUERY_STRING']:
357: qs=self.REQUEST['QUERY_STRING']
358:
359:
360: qs=string.join(qs.split("&"),",")
361:
362: for field in argv.keys():
363:
364: qs+=",-%s=%s"%(field,argv[field])
365: #print qs
366: else:
367:
368: qs=self.REQUEST.SESSION['query']
369: for field in argv.keys():
370: #print field
371: qs+=",-%s=%s"%(field,argv[field])
372:
373: else:
374: self.REQUEST['QUERY_STRING']=qs
375:
376: qs=string.join(qs.split("&"),",")
377:
378:
379:
380: qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.
381:
382: qs=string.join(delEmpty(qs.split(",")),",")
383:
384: if storename:
385: """store"""
386: else:
387: storename="foundCount"
388:
389:
390:
391: ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename)
392: #print self.REQUEST.SESSION["foundCount"]
393:
394:
395: return ret
396:
397: def ZSQLFoundCountLen(self,var):
398: return len(var)
399:
400: def ZSQLFoundCount(self,qs="",select="*",storename=None):
401:
402: ## if qs=="":
403:
404: ## if self.REQUEST['QUERY_STRING']:
405:
406: ## qs=self.REQUEST['QUERY_STRING']
407: ## qs=string.join(qs.split("&"),",")
408: ## else:
409:
410: ## qs=self.REQUEST.SESSION['query']
411: ## else:
412: ## qs=string.join(qs.split("&"),",")
413:
414:
415: ## temp= self.parseQueryString(qs,"-",select=select,storemax="yes",nostore="yes")
416: if storename:
417: """store"""
418: else:
419: storename="foundCount"
420:
421: return self.REQUEST.SESSION[storename]['count']
422:
423: def ZSQLRangeStart(self,storename=None):
424:
425: if storename:
426: """store"""
427: else:
428: storename="foundCount"
429:
430: return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
431:
432: def ZSQLRangeSize(self,storename=None):
433:
434: if storename:
435: """store"""
436: else:
437: storename="foundCount"
438:
439: return self.REQUEST.SESSION[storename]['rangeSize']
440:
441: def ZSQLRangeEnd(self,storename=None):
442:
443: if storename:
444: """store"""
445: else:
446: storename="foundCount"
447:
448: return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))
449:
450: def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None):
451: """analysieren den QueryString"""
452: #print "NO",nostore
453: lop="AND" # standardsuche mit and
454: max="ALL" #standard alle auswählen
455: maxstr=""
456: whereList=[]
457: sort=""
458: op="bw"
459: opfields={}
460: skip=""
461: rangeStart=0
462: limit=0
463: searchFields={}
464:
465: if not select:
466: select="oid,*"
467: #print "Q",nostore,qs
468: #check for op in the case of inline search
469:
470: splitted=qs.split(",")
471:
472:
473: for q in splitted:
474:
475: name=re.sub("r'+'"," ",q.split("=")[0].lower())
476: try:
477: value=urllib.unquote(q.split("=",1)[1])
478: except:
479: value=""
480: #print "Hi",name[0:3],q
481: if name[0:3]==iCT+"op":
482: op=value
483:
484: field=name[4:]
485: opfields[field]=op
486: #print "HI",op,field
487: #print opfieldsa
488: #now analyse the querystring
489: for q in qs.split(","):
490:
491:
492: #try:
493:
494: name=re.sub("r'+'"," ",q.split("=")[0].lower())
495: try:
496: value=urllib.unquote(q.split("=",1)[1])
497: except:
498: value=""
499:
500: #value=libpq.PgQuoteString(value)
501:
502:
503: if name==iCT+"lop":
504: lop=value
505: elif name==iCT+"table":
506: table=value
507: elif name==iCT+"select":
508: select=value
509: elif name==iCT+"max":
510: maxstr="LIMIT "+str(value)
511: limit=str(value)
512: elif name==iCT+"skip":
513: skip="OFFSET "+str(value)
514: rangeStart=str(value)
515: elif name==iCT+"join":
516: whereList.append(value)
517: elif name==iCT+"sort":
518: sort="ORDER BY "+value
519: elif name==iCT+"token":
520: if not nostore=="yes":
521: self.REQUEST.SESSION['token']=value
522:
523: elif name==iCT+"op":
524: op=value
525:
526:
527:
528: elif (not name[0]==iCT) and (not len(value)==0):
529:
530: #print "OP",op,name
531: value=value.lower()
532:
533: searchFields[name]=value
534:
535: if opfields.has_key(name):
536: op=opfields[name]
537: else:
538: op="ct"
539: name="LOWER("+name+")"
540: if op=="ct":
541: whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))
542: elif op=="gt":
543: whereList.append(name+">"+libpq.PgQuoteString(value))
544: elif op=="lt":
545: whereList.append(name+"<"+libpq.PgQuoteString(value))
546: elif op=="eq":
547: whereList.append(name+"="+libpq.PgQuoteString(value))
548: elif op=="bw":
549: whereList.append(name+" LIKE "+libpq.PgQuoteString(value+"%"))
550: elif op=="ew":
551: whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value))
552: op="ct"
553:
554: #except:
555: # print "END",value,name,Exception
556: if len(whereList)>0:
557: where="WHERE "+string.join(whereList," "+lop+" ")
558: else:
559: where=""
560: #print "QE",table
561:
562: query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)
563:
564: if not nostore=="yes":
565:
566: self.REQUEST.SESSION['qs']=opfields
567: #print "IAMHERE again:", query
568:
569: if storename:
570: query2="SELECT count(*) FROM %s %s"%(table,where)
571: #print "storing",query2
572: #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
573: if not self.REQUEST.SESSION.has_key(storename):
574: self.REQUEST.SESSION[storename]={}
575: if self.REQUEST.SESSION[storename].has_key('queryString2'):
576: #print "HI",storename
577: if not self.REQUEST.SESSION[storename]['queryString2']==query2:
578: #print "HOOOOO",storename
579: self.REQUEST.SESSION[storename]['queryString2']=query2
580: self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(var=query2)[0].count
581: #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']
582:
583: else:
584: self.REQUEST.SESSION[storename]['queryString2']=query2
585: self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(var=query2)[0].count
586: #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
587:
588:
589: self.REQUEST.SESSION[storename]['rangeStart']=rangeStart
590: if limit=="all":
591: self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
592: else:
593: self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
594: self.REQUEST.SESSION[storename]['rangeSize']=limit
595: self.REQUEST.SESSION[storename]['searchFields']=searchFields
596:
597: #print "Q",query
598: return self.ZSQLQuery(query)
599:
600: def ZSQLQuery(self,query):
601: """query"""
602: return self.ZSQLSimpleSearch(var=query)
603:
604: def ZSQLSearch(self):
605: """To be done"""
606: rq=self.REQUEST['QUERY_STRING']
607: querys=rq.split("&")
608:
609:
610: for querytemp in querys:
611: query=querytemp.split("=")
612: try:
613: if query[0].lower()=="-format":
614: formatfile=query[1]
615: except:
616: """nothing"""
617: #print formatfile
618: self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
619: return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))
620:
621:
622: def ZSQLint(self,string):
623: try:
624:
625: return(int(string))
626: except:
627: return 0
628:
629: def getZSQLSearchFieldsList(self,storename="foundCount"):
630: """get searchfieldList"""
631: #print self.REQUEST.SESSION[storename]['searchFields'].keys()
632: return self.REQUEST.SESSION[storename]['searchFields'].keys()
633:
634: def getZSQLSearchFields(self,storename="foundCount"):
635: """get searchfield"""
636: #print "SF",self.REQUEST.SESSION[storename]['searchFields']
637: return self.REQUEST.SESSION[storename]['searchFields']
638:
639:
640: def nextLink(self,html,storename="foundCount"):
641: """nextLink"""
642: try:
643: limit=self.REQUEST.SESSION[storename]['rangeSize']
644: if int(limit)==0 :
645: limit="1"
646: newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)
647: except:
648: limit=1
649: newRangeStart=0
650:
651: if newRangeStart>=self.REQUEST.SESSION[storename]['count']:
652: #newRangeStart=self.REQUEST.SESSION[storename]['count']-1
653: return ""
654:
655: #create new query string
656:
657: if self.REQUEST['QUERY_STRING']=="":
658: qs=self.REQUEST.SESSION['query']
659:
660: queries=string.split(qs,",")
661:
662:
663: else:
664: qs=self.REQUEST['QUERY_STRING']
665: queries=string.split(qs,"&")
666:
667:
668:
669: newquery=[]
670:
671: skipFound=0
672:
673: for query in queries:
674:
675: #print query.split("=")[0]
676: if query[0]=="_" : query[0]="-"
677:
678: if query.split("=")[0].lower()=="-skip":
679:
680: skipFound=1
681: query="-skip=%i"%newRangeStart
682: newquery.append(query)
683:
684: if skipFound==0 :
685: query="-skip=%i"%newRangeStart
686: newquery.append(query)
687:
688: newquerystring=string.join(newquery,"&")
689:
690: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
691:
692:
693: def prevLink(self,html,storename="foundCount"):
694: """prev link"""
695: try:
696: limit=self.REQUEST.SESSION[storename]['rangeSize']
697: if int(limit)==0 :
698: limit="1"
699: newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])-int(limit)
700: except:
701: limit=1
702: newRangeStart=0
703: if newRangeStart <0:
704: return ""
705:
706: #print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])
707:
708: if newRangeStart<0:
709: newRangeStart=0
710:
711: #create new query string
712:
713: if self.REQUEST['QUERY_STRING']=="":
714: qs=self.REQUEST.SESSION['query']
715: #qs=re.sub(r'_','-',qs) #aendern für query
716: queries=string.split(qs,",")
717:
718:
719: else:
720: qs=self.REQUEST['QUERY_STRING']
721: queries=string.split(qs,"&")
722:
723:
724:
725: newquery=[]
726:
727: skipFound=0
728:
729: for query in queries:
730: #print query.split("=")[0]
731:
732: if query[0]=="_" : query[0]="-"
733:
734: if query.split("=")[0].lower()=="-skip":
735: #print"HI"
736: query="-skip=%i"%newRangeStart
737: skipFound=1
738: newquery.append(query)
739:
740: if skipFound==0 :
741: query="-skip=%i"%newRangeStart
742: newquery.append(query)
743:
744: newquerystring=string.join(newquery,"&")
745:
746: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
747:
748:
749:
750: def prevLink_old(self,html):
751: """prev link"""
752: if self.REQUEST['QUERY_STRING']=="":
753: qs=self.REQUEST.SESSION['query']
754: else:
755: qs=self.REQUEST['QUERY_STRING']
756: max=re.search(r'max\=(.*)\,',qs.lower())
757: offset=re.search(r'offset\=(.*)\,',qs.lower())
758: if not offset:
759: offsetnew=0
760: else:
761: offsetnew=int(offset)-max
762: if offsetnew<0:
763: offsetnew=0
764: queries=string.split(qs,",")
765: newquery=[]
766: if offset:
767: for query in queries:
768: if query.split("=")[0].lower()=="offset":
769: query="-offset=%i"%offsetnew
770: newquery.append(query)
771: newquerystring=string.join(newquery,"&")
772: else:
773: queries.append("-offset=%i"%offsetnew)
774: newquerystring=string.join(queries,"&")
775: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
776:
777: def nextLink_old(self,html):
778: """prev link"""
779: if self.REQUEST['QUERY_STRING']=="":
780: qs=self.REQUEST.SESSION['query']
781: else:
782: qs=self.REQUEST['QUERY_STRING']
783: max=re.search(r'max\=(.*)\,',qs.lower())
784:
785: offset=re.search(r'offset\=(.*)\,',qs.lower())
786: if not offset:
787: offsetnew=1
788: else:
789: offsetnew=int(offset)+int(max)
790: if offsetnew<0:
791: offsetnew=0
792: queries=string.split(qs,",")
793: newquery=[]
794: if offset:
795: for query in queries:
796:
797: if query.split("=")[0].lower()=="-offset":
798: query="-offset=%i"%offsetnew
799: newquery.append(query)
800: newquerystring=string.join(newquery,"&")
801: else:
802: queries.append("-offset=%i"%offsetnew)
803: newquerystring=string.join(queries,"&")
804:
805: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
806:
807:
808: manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())
809:
810: def manage_addZSQLExtendFolder(self, id, title='', label='', description='',
811: createPublic=0,
812: createUserF=0,
813: connection_id=None,
814: REQUEST=None):
815: """Add a new Folder object with id *id*.
816:
817: If the 'createPublic' and 'createUserF' parameters are set to any true
818: value, an 'index_html' and a 'UserFolder' objects are created respectively
819: in the new folder.
820: """
821:
822:
823: ob=ZSQLExtendFolder()
824: ob.id=str(id)
825: ob.title=title
826: self._setObject(id, ob)
827: ob=self._getOb(id)
828: setattr(ob,'label',label)
829: setattr(ob,'description',description)
830: setattr(ob,'connection_id',connection_id)
831:
832: checkPermission=getSecurityManager().checkPermission
833:
834: if createUserF:
835: if not checkPermission('Add User Folders', ob):
836: raise Unauthorized, (
837: 'You are not authorized to add User Folders.'
838: )
839: ob.manage_addUserFolder()
840:
841: if createPublic:
842: if not checkPermission('Add Page Templates', ob):
843: raise Unauthorized, (
844: 'You are not authorized to add Page Templates.'
845: )
846: ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
847: id='index_html', title='')
848:
849: if REQUEST is not None:
850: return self.manage_main(self, REQUEST, update_menu=1)
851:
852:
853:
854: class ZSQLBibliography(Folder,ZSQLExtendFolder):
855: """Bibliography"""
856: meta_type="ZSQLBibliography"
857: def getLabel(self):
858: try:
859: return self.label
860: except:
861: return ""
862:
863: def getDescription(self):
864: try:
865: return self.description
866: except:
867: return ""
868:
869: def changeZSQLBibliographyForm(self):
870: """change folder config"""
871: pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLBibliographyForm.zpt').__of__(self)
872: return pt()
873:
874:
875: def content_html(self):
876: """template fuer content"""
877:
878: try:
879: obj=getattr(self,"ZSQLBibliography_template")
880: return obj()
881: except:
882: pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt').__of__(self)
883: pt.content_type="text/html"
884: return pt()
885:
886: def changeZSQLBibliography(self,tableName,label,description,REQUEST=None):
887: """change it"""
888: self.tableName=tableName
889: self.label=label
890: self.description=description
891:
892: if REQUEST is not None:
893: return self.manage_main(self, REQUEST)
894:
895: manage_options=Folder.manage_options+(
896: {'label':'Main Config','action':'changeZSQLBibliographyForm'},
897: )
898:
899:
900: def getFieldLabel(self,fields,field):
901: """get labels"""
902: try:
903: ret =fields[0][field]
904: if ret == "":
905: return field
906: else:
907: return ret
908: except:
909: return field
910:
911: def getFieldValue(self,found,field):
912: """get value"""
913: try:
914: ret=getattr(found,field)
915: if ret == "":
916: return None
917: else:
918: return ret
919: except:
920: return None
921:
922: def findTagsFromMapping(self,referenceType):
923: """gib hash mit label -> generic zurueck"""
924: self.referencetypes=self.ZopeFind(self.standardMD)
925: bibdata={}
926: retdata={}
927: fieldlist=self.standardMD.fieldList
928:
929: for referenceTypeF in self.referencetypes:
930: #print referenceType,referenceTypeF[1].title
931: if referenceTypeF[1].title == referenceType:
932: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
933: bibdata['data']=referenceTypeF[1]
934: self.fields=bibdata[referenceType]
935: for field in fieldlist:
936: if referenceTypeF[1].getValue(field)[0]==None:
937: retdata[field]=field
938: else:
939: retdata[field]=referenceTypeF[1].getValue(field)[0]
940:
941: return retdata,fieldlist
942:
943: def findLabelsFromMapping(self,referenceType):
944: """gib hash mit label -> generic zurueck"""
945: self.referencetypes=self.ZopeFind(self.standardMD)
946: bibdata={}
947: retdata={}
948: fieldlist=self.standardMD.fieldList
949:
950: for referenceTypeF in self.referencetypes:
951: #print referenceType,referenceTypeF[1].title
952: if referenceTypeF[1].title == referenceType:
953: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
954: bibdata['data']=referenceTypeF[1]
955: self.fields=bibdata[referenceType]
956: for field in fieldlist:
957: retdata[field]=referenceTypeF[1].getValue(field)[1]
958:
959: return retdata,fieldlist
960:
961: def createIndexTag(self,tag,content):
962: """creste tag"""
963: if content:
964: ret="""<%s>%s</%s>"""%(tag,content,tag)
965: return ret
966: else:
967: return ""
968:
969: def getMetaDataXML2(self):
970: """crate index meta"""
971:
972: fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
973: self.REQUEST['fn']=fn
974:
975: pt=PageTemplateFile('Products/ZSQLExtend/zpt/record2.xml').__of__(self)
976: pt.content_type="text/xml"
977: return pt()
978:
979: def getMetaDataXML(self):
980: """crate index meta"""
981: pt=PageTemplateFile('Products/ZSQLExtend/zpt/record.xml').__of__(self)
982: pt.content_type="text/xml"
983: return pt()
984:
985: def getMetaDatasXML(self):
986: """index"""
987: ret="""<?xml version="1.0" ?>
988: <index>"""
989: for found in self.ZSQLSimpleSearch(var="select oid from %s limit ALL"%self.tableName):
990: link=self.absolute_url()+"/"+"record.html?oid=%i"%found.oid
991: metalink=self.absolute_url()+"/"+"getMetaDataXML?oid=%i"%found.oid
992:
993: ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)
994:
995: return ret+"\n</index>"
996:
997:
998: manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())
999:
1000: def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
1001: createPublic=0,
1002: createUserF=0,
1003: REQUEST=None):
1004: """Add a new Folder object with id *id*.
1005:
1006: If the 'createPublic' and 'createUserF' parameters are set to any true
1007: value, an 'index_html' and a 'UserFolder' objects are created respectively
1008: in the new folder.
1009: """
1010:
1011:
1012: ob=ZSQLBibliography()
1013: ob.id=str(id)
1014: ob.title=title
1015: self._setObject(id, ob)
1016: ob=self._getOb(id)
1017: setattr(ob,'tableName',tableName)
1018: setattr(ob,'label',label)
1019: setattr(ob,'description',description)
1020:
1021: checkPermission=getSecurityManager().checkPermission
1022:
1023: if createUserF:
1024: if not checkPermission('Add User Folders', ob):
1025: raise Unauthorized, (
1026: 'You are not authorized to add User Folders.'
1027: )
1028: ob.manage_addUserFolder()
1029:
1030: if createPublic:
1031: if not checkPermission('Add Page Templates', ob):
1032: raise Unauthorized, (
1033: 'You are not authorized to add Page Templates.'
1034: )
1035: ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
1036: id='index_html', title='')
1037:
1038: if REQUEST is not None:
1039: return self.manage_main(self, REQUEST, update_menu=1)
1040:
1041:
1042:
1043:
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