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