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