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 ""
165: def index_html(self,mode='open'):
166: """generische ansicht"""
167:
168: #check if user has right for other modi
169:
170: if hasattr(self,"BasketFolder_template"):
171: obj=getattr(self,"BaskeFolder_template")
172: return obj()
173: else:
174: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketFolder_template_standard.zpt')).__of__(self)
175: pt.content_type="text/html"
176: return pt(mode=mode)
177:
178: def __init__(self,id,title):
179: """init basket folder"""
180:
181: self.id=id
182: self.title=title
183:
184: def manageBasketFolder(self):
185: """manage the basket"""
186:
187: if hasattr(self,"BasketFolder_manage_template"):
188: obj=getattr(self,"BasketFolder_manage_template")
189: return obj()
190: else:
191: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketFolder_manage_template_standard.zpt')).__of__(self)
192: pt.content_type="text/html"
193: return pt()
194:
195: def addBasket(self,title,RESPONSE=None):
196: """add a new basket"""
197: id=self.getNewId()
198: username=self.getActualUserName()
199: publicationStatus="private"
200: manage_addBasket(self,str(id),title,"",username,publicationStatus,RESPONSE=None)
201: newObj=getattr(self,str(id))
202: #create a groupfolder
203:
204: manage_addGroupFolder(newObj,'groupFolder')
205:
206: #add current user to admin group of the new set
207:
208: newObj.groupFolder.addUserToGroups(str(self.REQUEST['AUTHENTICATED_USER']),['admin'])
209: if RESPONSE:
210: RESPONSE.redirect(newObj.absolute_url()+'/manageBasket')
211:
212:
213: def manage_addBasketFolderForm(self):
214: """form for adding a basket"""
215: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketFolder.zpt')).__of__(self)
216: return pt()
217:
218: def manage_addBasketFolder(self,id,title,RESPONSE=None):
219: """add a basket folder object"""
220:
221:
222: newObj=BasketFolder(id,title)
223:
224: self._setObject(id,newObj)
225:
226: if RESPONSE is not None:
227: RESPONSE.redirect('manage_main')
228:
229: class Basket(BasketBasis):
230: """Basket class"""
231:
232: meta_type="basket"
233:
234: security=ClassSecurityInfo()
235:
236: publicationStatusList=publicationStatusList
237:
238: manage_options=OrderedFolder.manage_options+(
239: {'label':'manage main','action':'changeBasketForm'},
240: )
241:
242: def checkPermission(self,modus):
243: """check permission"""
244: if modus=='open':
245: return True
246: elif modus=='private':
247: return self.groupFolder.isMemberOf('admin')
248: elif modus=='admin':
249: return self.groupFolder.isMemberOf('admin')
250: elif modus=='edit':
251: return self.groupFolder.isMemberOf('edit')
252: elif modus=='publish':
253: return self.groupFolder.isMemberOf('publish')
254:
255: def manageUserRights_html(self):
256: """manage user rights"""
257: if hasattr(self,"Basket_manageUserRights_template"):
258: obj=getattr(self,"Basket_manageUserRights_template")
259: return obj()
260: else:
261: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_Basket_manageUserRights_standard.zpt')).__of__(self)
262: pt.content_type="text/html"
263: return pt()
264:
265:
266: def getBasketObjects(self):
267: """get all basket objects"""
268:
269: objs=self.getObjects()
270: ret=[]
271: for x in objs:
272: if x.meta_type in basketMetatypes:
273: ret.append(x)
274: return ret
275:
276: def checkRef(self,xref):
277: """check if XRef is already in Basket"""
278:
279: founds=self.ZopeFind(self,obj_metatypes=["BasketXRef"])
280: for found in founds:
281: if self.xref==xref:
282: return True
283: return False
284:
285: def __init__(self,id,title,comment,owner,publicationStatus,shortDescription):
286: '''
287: init the basket
288: @param id: id
289: @param title: title of the basket
290: @param comment: description of the basket
291: @param shortDescription: short description of the basket for the overviewList
292: @param owner: user object describing the owner
293: @param publication_status: one of publicationStatus if restricted, optional parameter accessGroups has to be set
294: '''
295:
296: self.id=id
297: self.title=title
298: self.comment=comment
299: self.owner=owner
300: self.publicationStatus=publicationStatus
301: self.shortDescription=shortDescription
302:
303:
304:
305: def getTitle(self):
306: """print name"""
307: return self.title
308:
309: security.declareProtected('Manage','changeBasketForm')
310: def changeBasketForm(self):
311: """form for changing the basket"""
312: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasket.zpt')).__of__(self)
313: return pt()
314:
315:
316: def changeBasket(self,title,comment,shortDescription,publicationStatus=None,username=None,accessGroups=None,RESPONSE=None,target=None):
317: '''
318: init the basket
319: @param title: title of the basket
320: @param comment: description of the basket
321: @param owner: user object describing the owner
322: @param publication_status: one of publicationStatus if restricted, optional parameter accessGroups has to be set
323: @param aaccessGroups: default value is none, contains list of groups which are allowed to access this basket
324: '''
325: #TODO:what happens in username does not exists
326: #find username
327: owner=username
328:
329: self.title=title
330: self.comment=comment
331: if owner:
332: self.owner=owner
333: if publicationStatus:
334: self.publicationStatus=publicationStatus
335: if accessGroups:
336: self.accessGroups=accessGroups
337: self.shortDescription=shortDescription
338:
339:
340: if RESPONSE is not None:
341: if target:
342: RESPONSE.redirect(target)
343: else:
344: RESPONSE.redirect('manage_main')
345:
346: def index_html(self):
347: """generische ansicht"""
348:
349: if hasattr(self,"BasketMain_template"):
350: obj=getattr(self,"BasketMain_template")
351: return obj()
352: else:
353: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_template_standard.zpt')).__of__(self)
354: pt.content_type="text/html"
355: return pt()
356:
357: def manageBasket(self):
358: """manage the basket"""
359:
360: if hasattr(self,"BasketMain_manage_template"):
361: obj=getattr(self,"BasketMain_manage_template")
362: return obj()
363: else:
364: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_manage_template_standard.zpt')).__of__(self)
365: pt.content_type="text/html"
366: return pt()
367:
368:
369: def changeBasketComments(self,REQUEST):
370: """Change comment of basket elements"""
371: form=REQUEST.form
372:
373: for key in form.keys():
374: splitted=key.split("_")
375: objects=self.ZopeFind(self,obj_ids=[splitted[0]])
376: if len(objects)>0:
377: setattr(objects[0][1],splitted[1],form[key])
378:
379:
380: if REQUEST:
381: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
382:
383:
384: def selectThisBasketAsCurrent(self,REQUEST=None):
385: """select this basket for further work"""
386: REQUEST.RESPONSE.setCookie('vlp_basket',self.getId(),path="/")
387:
388: if REQUEST:
389: REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
390:
391:
392: def generateNewObject(self,type,link,title='',comment='',REQUEST=None):
393: """generate a new object in the basket"""
394:
395: if type=="xref":
396:
397: splitted=urllib.unquote(link).split("?")
398: if len(splitted)>1:
399: #assumes references id is contained in the url as parameter id=
400: params=cgi.parse_qs(splitted[1])
401: xref=params.get('id',None)
402: return False
403: else:
404: #addumes link contains only the reference id
405: xref=link
406:
407: id=self.getNewId()
408: title=""
409:
410: if xref is None:
411: #no parameter id
412: return False
413: manage_addBasketXRef(self,str(id),title,comment,xref)
414:
415: if REQUEST:
416: import random
417: rd=random.random()
418: REQUEST.RESPONSE.redirect(REQUEST['HTTP_REFERER']+'&-dummy='+str(rd))
419: else:
420: return True
421:
422: def manage_addBasketForm(self):
423: """form for adding a basket"""
424: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
425: return pt()
426:
427: def manage_addBasket(self,id,title,comment,username,publicationStatus,shortDescription="",accessGroups=None,RESPONSE=None):
428: """add a basket object"""
429: #TODO:what happens in username does not exists
430: #find username
431: owner=username
432:
433: newObj=Basket(id,title,comment,owner,publicationStatus,shortDescription)
434:
435: self._setObject(id,newObj)
436:
437: if RESPONSE is not None:
438: RESPONSE.redirect('manage_main')
439:
440: class BasketBasis(SimpleItem):
441: """basic class for baskets"""
442:
443: #security=ClassSecurityInfo()
444:
445: manage_options=SimpleItem.manage_options+(
446: {'label':'manage main','action':'changeBasketBasisForm'},
447: )
448:
449: def __init__(self,id,title,comment):
450: '''
451: init basket basis
452: @param id: id
453: @param title: title
454: @param comment commentar:
455: '''
456: self.id=id
457: self.title=title
458: self.comment=comment
459:
460: def changeBasketBasisForm(self):
461: """form for changing the basket"""
462: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketBasis.zpt')).__of__(self)
463: return pt()
464:
465: def changeBasketBasis(self,title,comment,RESPONSE=None):
466: '''
467: init the basket
468: @param title: title of the basket
469: @param comment: description of the basket
470: '''
471:
472: self.title=title
473: self.comment=comment
474:
475: if RESPONSE is not None:
476: RESPONSE.redirect('manage')
477:
478: def linkToObject(self):
479: """generate url to open the resource, has to be implemented in the different objects, generic return None"""
480: return None
481:
482: def content_html(self,type):
483: """generische ausgabe des objectes als html"""
484: if hasattr(self,type+"_template"):
485: obj=getattr(self,type+"_template")
486: return obj()
487: else:
488: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','%s_template_standard.zpt'%type)).__of__(self)
489: pt.content_type="text/html"
490: return pt()
491:
492: class BasketXRef(BasketBasis):
493: """class for internal references based on xrefs"""
494:
495: #security=ClassSecurityInfo()
496: meta_type="BasketXRef"
497:
498: manage_options=BasketBasis.manage_options+(
499: {'label':'manage xref','action':'changeBasketXRefForm'},
500: )
501:
502: def changeBasketXRefForm(self):
503: """form for changing the basket"""
504: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketXRef.zpt')).__of__(self)
505: return pt()
506:
507: def changeBasketXRef(self,xref,RESPONSE=None):
508: '''
509: change the basket
510: @param xref: reference
511: '''
512:
513: self.xref=xref
514:
515: if RESPONSE is not None:
516: RESPONSE.redirect('manage')
517:
518: def linkToObject(self):
519: """generate url to open the resource"""
520: return refBasis%self.xref
521:
522: def content_html(self):
523: """format object as html fragment"""
524:
525: type=self.xref[0:3]
526: return BasketBasis.content_html(self,"BasketXRef_%s"%type)
527:
528: def manage_addBasketXRefForm(self):
529: """form for adding a basket"""
530: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketXRef.zpt')).__of__(self)
531: return pt()
532:
533: def manage_addBasketXRef(self,id,title,comment,xref,RESPONSE=None):
534: """add a basketXRef object"""
535:
536:
537: newObj=BasketXRef(id,title,comment)
538: newObj.xref=xref
539:
540: self._setObject(id,newObj)
541:
542: if RESPONSE is not None:
543: RESPONSE.redirect('manage_main')
544:
545: class BasketInternalLink(BasketBasis):
546: """class for internal referencens based on links"""
547:
548: #security=ClassSecurityInfo()
549: meta_type="BasketInternalLink"
550:
551: manage_options=BasketBasis.manage_options+(
552: {'label':'manage internal link','action':'changeBasketInternalLinkForm'},
553: )
554:
555: def changeBasketInternalLinkForm(self):
556: """form for changing the basket"""
557: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketInternalLink.zpt')).__of__(self)
558: return pt()
559:
560: def changeBasketInternalLink(self,link,linkText,RESPONSE=None):
561: '''
562: change the Internallink
563: @param link: reference
564: @param linkText: reference
565: '''
566:
567: self.link=link
568: self.linkText=linkText
569:
570: if RESPONSE is not None:
571: RESPONSE.redirect('manage')
572:
573: def content_html(self):
574: """format object as html fragment"""
575:
576: return BasketBasis.content_html(self,"BasketInternalLink")
577:
578: def linkToObject(self):
579: """link to the object (internalLink)"""
580: return self.link
581:
582: def manage_addBasketInternalLinkForm(self):
583: """form for adding a basket"""
584: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketInternalLink.zpt')).__of__(self)
585: return pt()
586:
587: def manage_addBasketInternalLink(self,id,title,comment,link,linkText,RESPONSE=None):
588: """add a basketXRef object"""
589:
590:
591: newObj=BasketInternalLink(id,title,comment)
592: newObj.link=link
593: newObj.linkText=linkText
594:
595: self._setObject(id,newObj)
596:
597: if RESPONSE is not None:
598: RESPONSE.redirect('manage_main')
599:
600:
601: class BasketExternalLink(BasketBasis):
602: """class for external links"""
603:
604: #security=ClassSecurityInfo()
605: meta_type="BasketExternalLink"
606:
607: manage_options=BasketBasis.manage_options+(
608: {'label':'manage internal link','action':'changeBasketExternalLinkForm'},
609: )
610:
611: def changeBasketExternalLinkForm(self):
612: """form for changing the basket"""
613: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketExternalLink.zpt')).__of__(self)
614: return pt()
615:
616: def changeBasketExternalLink(self,link,linkText,RESPONSE=None):
617: '''
618: change the Externallink
619: @param link: reference
620: @param linkText: reference
621: '''
622:
623: self.link=link
624: self.linkText=linkText
625:
626: if RESPONSE is not None:
627: RESPONSE.redirect('manage')
628:
629: def content_html(self):
630: """format object as html fragment"""
631:
632: return BasketBasis.content_html(self,"BasketExternalLink")
633:
634: def linkToObject(self):
635: """link to the object (externalLink)"""
636: return self.link
637:
638: def manage_addBasketExternalLinkForm(self):
639: """form for adding a basket"""
640: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketExternalLink.zpt')).__of__(self)
641: return pt()
642:
643: def manage_addBasketExternalLink(self,id,title,comment,link,linkText,RESPONSE=None):
644: """add a basket external link object"""
645:
646: newObj=BasketExternalLink(id,title,comment)
647: newObj.link=link
648: newObj.linkText=linkText
649:
650: self._setObject(id,newObj)
651:
652: if RESPONSE is not None:
653: RESPONSE.redirect('manage_main')
654:
655:
656: class BasketText(BasketBasis):
657: """class for text elements in baskets"""
658:
659: #security=ClassSecurityInfo()
660: meta_type="BasketText"
661:
662: def content_html(self):
663: """format object as html fragment"""
664: return "" # text has no content
665: #return BasketBasis.content_html(self,"BasketText")
666:
667: def manage_addBasketTextForm(self):
668: """form for adding a basket"""
669: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketText.zpt')).__of__(self)
670: return pt()
671:
672: def manage_addBasketText(self,id,title,comment,RESPONSE=None):
673: """add a basketXRef object"""
674:
675:
676: newObj=BasketText(id,title,comment)
677:
678: self._setObject(id,newObj)
679:
680: if RESPONSE is not None:
681: RESPONSE.redirect('manage_main')
682:
683:
684:
685:
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