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