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