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