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