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