1: ###objects to store and manage objects in baskets
2:
3: import os
4: import os.path
5: import urllib
6: import cgi
7:
8:
9: from OFS.OrderedFolder import OrderedFolder
10: from OFS.SimpleItem import SimpleItem
11: from OFS.Image import File
12:
13: from AccessControl import ClassSecurityInfo
14: from AccessControl.User import UserFolder
15: from Globals import InitializeClass
16: from Globals import DTMLFile
17: import Globals
18: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
19: from Products.PageTemplates.PageTemplate import PageTemplate
20: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
21: from Globals import Persistent, package_home
22: from Acquisition import Implicit
23: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
24:
25:
26: from groups import manage_addGroupFolder
27:
28: refBasis="http://vlp.mpiwg-berlin.mpg.de/references?id=%s"
29:
30: basketMetatypes=['BasketXRef','BasketInternalLink','BasketExternalLink','BasketText','BasketFile']
31:
32: #basis url for references
33:
34: publicationStatusList=['private','hidden','open_intern','open','group']
35: # private only access for the owner, restricted only for users in accessGroup, open open for everyone, published occurs in basket list
36:
37: class BasketBasis(OrderedFolder):
38: """Basis class for BasketFolder and Baskets"""
39:
40: security=ClassSecurityInfo()
41: def getNewId(self):
42: """createIds"""
43: last=getattr(self,'last',0)
44: last +=1
45: while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
46: last+=1
47:
48: return last
49:
50: def addBasketFile(self,REQUEST=None,fileUpload=None,comment=None,title=""):
51: """add a file to the basket"""
52: if fileUpload==None:
53: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketFile.zpt')).__of__(self)
54: pt.content_type="text/html"
55: return pt()
56: else:
57: id=self.getNewId()
58: if title=="":
59: title=fileUpload.filename
60:
61: manage_addBasketFile(self,id,title,comment,fileUpload)
62: if REQUEST:
63: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
64:
65: def addBasketText(self,REQUEST=None):
66: """add a text"""
67: id=self.getNewId()
68: manage_addBasketText(self,str(id),'','',RESPONSE=None)
69: if REQUEST:
70: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
71:
72: def addBasketExternalLink(self,REQUEST=None):
73: """add an external link"""
74: id=self.getNewId()
75:
76: manage_addBasketExternalLink(self,str(id),"","","","",RESPONSE=None)
77: if REQUEST:
78: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
79:
80: def deleteObject(self,id,REQUEST=None):
81: """delete object"""
82: self.manage_delObjects([id])
83: if REQUEST:
84: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
85:
86: def moveUp(self,id,REQUEST=None):
87: """move id one up"""
88: self.moveObjectsUp([id], 1)
89: if REQUEST:
90: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
91:
92: def moveDown(self,id,REQUEST=None):
93: """move id one up"""
94: self.moveObjectsDown([id], 1)
95: if REQUEST:
96: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
97:
98: def moveTop(self,id,REQUEST=None):
99: """move to top"""
100: self.moveObjectsToTop([id])
101: if REQUEST:
102: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
103:
104: def moveBottom(self,id,REQUEST=None):
105: """move to top"""
106: self.moveObjectsToBottom([id])
107: if REQUEST:
108: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
109:
110: security.declareProtected('View','getOwner')
111:
112: def getOwner(self):
113: """get Owner as string"""
114: return self.owner
115:
116: def isAuthorized(self,role="read"):
117: """check whether actual user is authorized"""
118: #TODO replace occurences with checkPermission
119: return True
120:
121: def getActualUserName(self):
122: """get username of actual user"""
123: return self.REQUEST['AUTHENTICATED_USER'].getUserName()
124:
125: def getObjects(self):
126: """"get objects"""
127: return [getattr(self,x['id']) for x in self._objects]
128:
129: def numberOfObjects(self):
130: """anzahl der elemente im basket"""
131: return len(self._objects)
132:
133: class BasketFolder(BasketBasis):
134: """Folder for Baskets"""
135:
136: meta_type="Basket Folder"
137:
138: #security=ClassSecurityInfo()
139:
140: def getSets(self,mode='open'):
141: """get sets, depending on mode selected"""
142: ret=[]
143:
144: if mode=='open':
145: for object in self.getObjects():
146:
147: if object.publicationStatus=='open':
148: ret.append(object)
149: return ret
150: elif mode=='open_intern':
151: print "open_intern"
152: if self.groupFolder.isMemberOf('user'):
153: print "---public"
154: for object in self.getObjects():
155: print object.getId(),object.publicationStatus
156: if object.publicationStatus=='open_intern':
157: ret.append(object)
158: return ret
159: else:
160: return ret
161: elif mode=='private':
162: for object in self.getObjects():
163: if object.groupFolder.isMemberOf('admin') or object.groupFolder.isMemberOf('editor'):
164: ret.append(object)
165: return ret
166: elif mode=='groups':
167: for object in self.getObjects():
168: if object.groupFolder.isMemberOf('reader') or object.groupFolder.isMemberOf('editor') or object.groupFolder.isMemberOf('admin'):
169: ret.append(object)
170: return ret
171:
172: def getCurrentBasket(self):
173: """select this basket for further work"""
174:
175: id=self.REQUEST.cookies.get('vlp_basket',None)
176: if id:
177: return getattr(self,id,None)
178: else:
179: return None
180:
181:
182: def index_html(self,mode='open'):
183: """generische ansicht"""
184:
185: #check if user has right for other modi
186:
187: if hasattr(self,"BasketFolder_template"):
188: obj=getattr(self,"BaskeFolder_template")
189: return obj()
190: else:
191: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketFolder_template_standard.zpt')).__of__(self)
192: pt.content_type="text/html"
193: return pt(mode=mode)
194:
195: def __init__(self,id,title):
196: """init basket folder"""
197:
198: self.id=id
199: self.title=title
200:
201: def manageBasketFolder(self):
202: """manage the basket"""
203:
204: if hasattr(self,"BasketFolder_manage_template"):
205: obj=getattr(self,"BasketFolder_manage_template")
206: return obj()
207: else:
208: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketFolder_manage_template_standard.zpt')).__of__(self)
209: pt.content_type="text/html"
210: return pt()
211:
212: def addBasket(self,title,RESPONSE=None):
213: """add a new basket"""
214: id=self.getNewId()
215: username=self.getActualUserName()
216: publicationStatus="private"
217: manage_addBasket(self,str(id),title,"",username,publicationStatus,RESPONSE=None)
218: newObj=getattr(self,str(id))
219: #create a groupfolder
220:
221: manage_addGroupFolder(newObj,'groupFolder')
222:
223: #add current user to admin group of the new set
224:
225: newObj.groupFolder.addUserToGroups(str(self.REQUEST['AUTHENTICATED_USER']),['admin'])
226: if RESPONSE:
227: RESPONSE.redirect(newObj.absolute_url()+'/manageBasket')
228:
229:
230: def manage_addBasketFolderForm(self):
231: """form for adding a basket"""
232: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketFolder.zpt')).__of__(self)
233: return pt()
234:
235: def manage_addBasketFolder(self,id,title,RESPONSE=None):
236: """add a basket folder object"""
237:
238:
239: newObj=BasketFolder(id,title)
240:
241: self._setObject(id,newObj)
242:
243: if RESPONSE is not None:
244: RESPONSE.redirect('manage_main')
245:
246: class Basket(BasketBasis):
247: """Basket class"""
248:
249: meta_type="basket"
250:
251: security=ClassSecurityInfo()
252:
253: publicationStatusList=publicationStatusList
254:
255: manage_options=OrderedFolder.manage_options+(
256: {'label':'manage main','action':'changeBasketForm'},
257: )
258:
259: def checkPermission(self,modus):
260: """check permission"""
261: if modus=='open':
262: return True
263: elif modus=='private':
264: return self.groupFolder.isMemberOf('admin')
265: elif modus=='admin':
266: return self.groupFolder.isMemberOf('admin')
267: elif modus=='edit':
268: return self.groupFolder.isMemberOf('edit')
269: elif modus=='publish':
270: return self.groupFolder.isMemberOf('publish')
271:
272: def manageUserRights_html(self):
273: """manage user rights"""
274: if hasattr(self,"Basket_manageUserRights_template"):
275: obj=getattr(self,"Basket_manageUserRights_template")
276: return obj()
277: else:
278: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_Basket_manageUserRights_standard.zpt')).__of__(self)
279: pt.content_type="text/html"
280: return pt()
281:
282:
283: def getBasketObjects(self):
284: """get all basket objects"""
285:
286: objs=self.getObjects()
287: ret=[]
288: for x in objs:
289: if x.meta_type in basketMetatypes:
290: ret.append(x)
291: return ret
292:
293: def checkRef(self,xref):
294: """check if XRef is already in Basket"""
295:
296: founds=self.ZopeFind(self,obj_metatypes=["BasketXRef"])
297: for found in founds:
298: if self.xref==xref:
299: return True
300: return False
301:
302: def __init__(self,id,title,comment,owner,publicationStatus,shortDescription):
303: '''
304: init the basket
305: @param id: id
306: @param title: title of the basket
307: @param comment: description of the basket
308: @param shortDescription: short description of the basket for the overviewList
309: @param owner: user object describing the owner
310: @param publication_status: one of publicationStatus if restricted, optional parameter accessGroups has to be set
311: '''
312:
313: self.id=id
314: self.title=title
315: self.comment=comment
316: self.owner=owner
317: self.publicationStatus=publicationStatus
318: self.shortDescription=shortDescription
319:
320:
321:
322: def getTitle(self):
323: """print name"""
324: return self.title
325:
326: security.declareProtected('Manage','changeBasketForm')
327: def changeBasketForm(self):
328: """form for changing the basket"""
329: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasket.zpt')).__of__(self)
330: return pt()
331:
332:
333: def changeBasket(self,title,comment,shortDescription,publicationStatus=None,username=None,accessGroups=None,RESPONSE=None,target=None):
334: '''
335: init the basket
336: @param title: title of the basket
337: @param comment: description of the basket
338: @param owner: user object describing the owner
339: @param publication_status: one of publicationStatus if restricted, optional parameter accessGroups has to be set
340: @param aaccessGroups: default value is none, contains list of groups which are allowed to access this basket
341: '''
342: #TODO:what happens in username does not exists
343: #find username
344: owner=username
345:
346: self.title=title
347: self.comment=comment
348: if owner:
349: self.owner=owner
350: if publicationStatus:
351: self.publicationStatus=publicationStatus
352: if accessGroups:
353: self.accessGroups=accessGroups
354: self.shortDescription=shortDescription
355:
356:
357: if RESPONSE is not None:
358: if target:
359: RESPONSE.redirect(target)
360: else:
361: RESPONSE.redirect('manage_main')
362:
363: def index_html(self):
364: """generische ansicht"""
365:
366: if hasattr(self,"BasketMain_template"):
367: obj=getattr(self,"BasketMain_template")
368: return obj()
369: else:
370: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_template_standard.zpt')).__of__(self)
371: pt.content_type="text/html"
372: return pt()
373:
374: def manageBasket(self):
375: """manage the basket"""
376:
377: if hasattr(self,"BasketMain_manage_template"):
378: obj=getattr(self,"BasketMain_manage_template")
379: return obj()
380: else:
381: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_manage_template_standard.zpt')).__of__(self)
382: pt.content_type="text/html"
383: return pt()
384:
385:
386: def changeBasketComments(self,REQUEST):
387: """Change comment of basket elements"""
388: form=REQUEST.form
389:
390: for key in form.keys():
391: splitted=key.split("_")
392: objects=self.ZopeFind(self,obj_ids=[splitted[0]])
393: if len(objects)>0:
394: setattr(objects[0][1],splitted[1],form[key])
395:
396:
397: if REQUEST:
398: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
399:
400:
401: def selectThisBasketAsCurrent(self,REQUEST=None):
402: """select this basket for further work"""
403: REQUEST.RESPONSE.setCookie('vlp_basket',self.getId(),path="/")
404:
405: if REQUEST:
406: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
407:
408:
409: def generateNewObject(self,type,link,title='',comment='',REQUEST=None):
410: """generate a new object in the basket"""
411:
412: if type=="xref":
413:
414: splitted=urllib.unquote(link).split("?")
415: if len(splitted)>1:
416: #assumes references id is contained in the url as parameter id=
417: params=cgi.parse_qs(splitted[1])
418: xref=params.get('id',None)
419: return False
420: else:
421: #addumes link contains only the reference id
422: xref=link
423:
424: id=self.getNewId()
425: title=""
426:
427: if xref is None:
428: #no parameter id
429: return False
430: manage_addBasketXRef(self,str(id),title,comment,xref)
431:
432: if REQUEST:
433: import random
434: rd=random.random()
435: REQUEST.RESPONSE.redirect(REQUEST['HTTP_REFERER']+'&-dummy='+str(rd))
436: else:
437: return True
438:
439: def manage_addBasketForm(self):
440: """form for adding a basket"""
441: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
442: return pt()
443:
444: def manage_addBasket(self,id,title,comment,username,publicationStatus,shortDescription="",accessGroups=None,RESPONSE=None):
445: """add a basket object"""
446: #TODO:what happens in username does not exists
447: #find username
448: owner=username
449:
450: newObj=Basket(id,title,comment,owner,publicationStatus,shortDescription)
451:
452: self._setObject(id,newObj)
453:
454: if RESPONSE is not None:
455: RESPONSE.redirect('manage_main')
456:
457: class BasketBasis(SimpleItem):
458: """basic class for baskets"""
459:
460: #security=ClassSecurityInfo()
461:
462: manage_options=SimpleItem.manage_options+(
463: {'label':'manage main','action':'changeBasketBasisForm'},
464: )
465:
466: def __init__(self,id,title,comment):
467: '''
468: init basket basis
469: @param id: id
470: @param title: title
471: @param comment commentar:
472: '''
473: self.id=id
474: self.title=title
475: self.comment=comment
476:
477: def changeBasketBasisForm(self):
478: """form for changing the basket"""
479: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketBasis.zpt')).__of__(self)
480: return pt()
481:
482: def changeBasketBasis(self,title,comment,RESPONSE=None):
483: '''
484: init the basket
485: @param title: title of the basket
486: @param comment: description of the basket
487: '''
488:
489: self.title=title
490: self.comment=comment
491:
492: if RESPONSE is not None:
493: RESPONSE.redirect('manage')
494:
495: def linkToObject(self):
496: """generate url to open the resource, has to be implemented in the different objects, generic return None"""
497: return None
498:
499: def content_html(self,type):
500: """generische ausgabe des objectes als html"""
501: if hasattr(self,type+"_template"):
502: obj=getattr(self,type+"_template")
503: return obj()
504: else:
505: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','%s_template_standard.zpt'%type)).__of__(self)
506: pt.content_type="text/html"
507: return pt()
508:
509: class BasketFile(BasketBasis,File):
510: """class for fileupload"""
511: meta_type="BasketFile"
512:
513: def __init__(self,id,title,comment,content_type='',precondition=''):
514: """init"""
515: self.id=id
516: self.title=title
517: self.comment=comment
518: self.content_type=content_type
519: self.precondition=precondition
520:
521:
522: def download(self):
523: """download the file"""
524: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.title)
525: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
526:
527: self.content_type="application/octet-stream"
528: self.REQUEST.RESPONSE.write(self.data)
529:
530:
531: def upDateFile(self,fileUpload=None,comment=None,title="",REQUEST=None):
532: """update file"""
533: if fileUpload==None:
534: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','upDateBasketFile.zpt')).__of__(self)
535: pt.content_type="text/html"
536: return pt()
537: else:
538: id=self.getNewId()
539: if title=="":
540: title=fileUpload.filename
541:
542: if fileUpload:
543: self.manage_upload(fileUpload)
544:
545: if comment:
546: self.comment=comment
547:
548: if REQUEST:
549: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
550:
551: def content_html(self):
552: """format object as html fragment"""
553:
554:
555: return BasketBasis.content_html(self,"BasketFile")
556:
557: def manage_addBasketFile(self,id,title,comment,fileUpload,content_type='',precondition='',REQUEST=None):
558: """add a basket file"""
559:
560: id=str(id)
561: title=str(title)
562: content_type=str(content_type)
563: precondition=str(precondition)
564:
565: #id, title = cookId(id, title, file)
566:
567: self=self.this()
568:
569: # First, we create the file without data:
570: self._setObject(id, BasketFile(id,title,comment,content_type, precondition))
571:
572: # Now we "upload" the data. By doing this in two steps, we
573: # can use a database trick to make the upload more efficient.
574: if fileUpload:
575: self._getOb(id).manage_upload(fileUpload)
576: if content_type:
577: self._getOb(id).content_type=content_type
578:
579: if REQUEST is not None:
580: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
581:
582: class BasketXRef(BasketBasis):
583: """class for internal references based on xrefs"""
584:
585: #security=ClassSecurityInfo()
586: meta_type="BasketXRef"
587:
588: manage_options=BasketBasis.manage_options+(
589: {'label':'manage xref','action':'changeBasketXRefForm'},
590: )
591:
592: def changeBasketXRefForm(self):
593: """form for changing the basket"""
594: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketXRef.zpt')).__of__(self)
595: return pt()
596:
597: def changeBasketXRef(self,xref,RESPONSE=None):
598: '''
599: change the basket
600: @param xref: reference
601: '''
602:
603: self.xref=xref
604:
605: if RESPONSE is not None:
606: RESPONSE.redirect('manage')
607:
608: def linkToObject(self):
609: """generate url to open the resource"""
610: return refBasis%self.xref
611:
612: def content_html(self):
613: """format object as html fragment"""
614:
615: type=self.xref[0:3]
616: return BasketBasis.content_html(self,"BasketXRef_%s"%type)
617:
618: def manage_addBasketXRefForm(self):
619: """form for adding a basket"""
620: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketXRef.zpt')).__of__(self)
621: return pt()
622:
623: def manage_addBasketXRef(self,id,title,comment,xref,RESPONSE=None):
624: """add a basketXRef object"""
625:
626:
627: newObj=BasketXRef(id,title,comment)
628: newObj.xref=xref
629:
630: self._setObject(id,newObj)
631:
632: if RESPONSE is not None:
633: RESPONSE.redirect('manage_main')
634:
635: class BasketInternalLink(BasketBasis):
636: """class for internal referencens based on links"""
637:
638: #security=ClassSecurityInfo()
639: meta_type="BasketInternalLink"
640:
641: manage_options=BasketBasis.manage_options+(
642: {'label':'manage internal link','action':'changeBasketInternalLinkForm'},
643: )
644:
645: def changeBasketInternalLinkForm(self):
646: """form for changing the basket"""
647: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketInternalLink.zpt')).__of__(self)
648: return pt()
649:
650: def changeBasketInternalLink(self,link,linkText,RESPONSE=None):
651: '''
652: change the Internallink
653: @param link: reference
654: @param linkText: reference
655: '''
656:
657: self.link=link
658: self.linkText=linkText
659:
660: if RESPONSE is not None:
661: RESPONSE.redirect('manage')
662:
663: def content_html(self):
664: """format object as html fragment"""
665:
666: return BasketBasis.content_html(self,"BasketInternalLink")
667:
668: def linkToObject(self):
669: """link to the object (internalLink)"""
670: return self.link
671:
672: def manage_addBasketInternalLinkForm(self):
673: """form for adding a basket"""
674: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketInternalLink.zpt')).__of__(self)
675: return pt()
676:
677: def manage_addBasketInternalLink(self,id,title,comment,link,linkText,RESPONSE=None):
678: """add a basketXRef object"""
679:
680:
681: newObj=BasketInternalLink(id,title,comment)
682: newObj.link=link
683: newObj.linkText=linkText
684:
685: self._setObject(id,newObj)
686:
687: if RESPONSE is not None:
688: RESPONSE.redirect('manage_main')
689:
690:
691: class BasketExternalLink(BasketBasis):
692: """class for external links"""
693:
694: #security=ClassSecurityInfo()
695: meta_type="BasketExternalLink"
696:
697: manage_options=BasketBasis.manage_options+(
698: {'label':'manage internal link','action':'changeBasketExternalLinkForm'},
699: )
700:
701: def changeBasketExternalLinkForm(self):
702: """form for changing the basket"""
703: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketExternalLink.zpt')).__of__(self)
704: return pt()
705:
706: def changeBasketExternalLink(self,link,linkText,RESPONSE=None):
707: '''
708: change the Externallink
709: @param link: reference
710: @param linkText: reference
711: '''
712:
713: self.link=link
714: self.linkText=linkText
715:
716: if RESPONSE is not None:
717: RESPONSE.redirect('manage')
718:
719: def content_html(self):
720: """format object as html fragment"""
721:
722: return BasketBasis.content_html(self,"BasketExternalLink")
723:
724: def linkToObject(self):
725: """link to the object (externalLink)"""
726: return self.link
727:
728: def manage_addBasketExternalLinkForm(self):
729: """form for adding a basket"""
730: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketExternalLink.zpt')).__of__(self)
731: return pt()
732:
733: def manage_addBasketExternalLink(self,id,title,comment,link,linkText,RESPONSE=None):
734: """add a basket external link object"""
735:
736: newObj=BasketExternalLink(id,title,comment)
737: newObj.link=link
738: newObj.linkText=linkText
739:
740: self._setObject(id,newObj)
741:
742: if RESPONSE is not None:
743: RESPONSE.redirect('manage_main')
744:
745:
746: class BasketText(BasketBasis):
747: """class for text elements in baskets"""
748:
749: #security=ClassSecurityInfo()
750: meta_type="BasketText"
751:
752: def content_html(self):
753: """format object as html fragment"""
754: return "" # text has no content
755: #return BasketBasis.content_html(self,"BasketText")
756:
757: def manage_addBasketTextForm(self):
758: """form for adding a basket"""
759: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketText.zpt')).__of__(self)
760: return pt()
761:
762: def manage_addBasketText(self,id,title,comment,RESPONSE=None):
763: """add a basketXRef object"""
764:
765:
766: newObj=BasketText(id,title,comment)
767:
768: self._setObject(id,newObj)
769:
770: if RESPONSE is not None:
771: RESPONSE.redirect('manage_main')
772:
773:
774:
775:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to basket.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / basket