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