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