Return to basket.py CVS log

Up to [Repository] / basket

*** empty log message ***

    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: publicationStatus=['private','restricted','open','published'] 
   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 Basket(OrderedFolder):
   31:     """Basket class"""
   32:     
   33:     meta_type="basket"
   34:     
   35:     security=ClassSecurityInfo()
   36:     
   37:     manage_options=OrderedFolder.manage_options+(
   38:         {'label':'manage main','action':'changeBasketForm'},
   39:         )
   40:     
   41:     def __init__(self,id,title,comment,owner,publicationStatus,shortDescription,accessGroups=None):
   42:         '''
   43:         init the basket
   44:         @param id: id
   45:         @param title: title of the basket
   46:         @param comment: description of the basket
   47:         @param shortDescription: short description of the basket for the overviewList
   48:         @param owner: user object describing the owner
   49:         @param publication_status: one of publicationStatus if restricted, optional parameter accessGroups has to be set
   50:         @param aaccessGroups: default value is none, contains list of groups which are allowed to access this basket
   51:         '''
   52:         
   53:         self.id=id
   54:         self.title=title
   55:         self.comment=comment
   56:         self.owner=owner
   57:         self.publicationStatus=publicationStatus
   58:         self.accessGroups=accessGroups
   59:         self.shortDecription=shortDescription
   60:         
   61:     security.declareProtected('View','getOwner')
   62:     
   63:     def getNewId(self):
   64:         """createIds"""
   65:         last=getattr(self,'last',0)
   66:         last +=1
   67:         while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
   68:             last+=1
   69:         return last
   70:         
   71:     def addBasketText(self,REQUEST=None):
   72:         """add a text"""
   73:         id=self.getNewId()
   74:         manage_addBasketText(self,str(id),'','',RESPONSE=None)
   75:         if REQUEST:
   76:             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
   77:     
   78:     def deleteObject(self,id,REQUEST=None):
   79:         """delete object"""
   80:         self.manage_delObjects([id])
   81:         if REQUEST:
   82:             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
   83:     
   84:     def moveUp(self,id,REQUEST=None):
   85:         """move id one up"""
   86:         self.moveObjectsUp([id], 1)
   87:         if REQUEST:
   88:             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
   89:     
   90:     def moveDown(self,id,REQUEST=None):
   91:         """move id one up"""
   92:         self.moveObjectsDown([id], 1)
   93:         if REQUEST:
   94:             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
   95:             
   96:     def moveTop(self,id,REQUEST=None):
   97:         """move to top"""
   98:         self.moveObjectsToTop([id])
   99:         if REQUEST:
  100:             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
  101:   
  102:     def moveBottom(self,id,REQUEST=None):
  103:         """move to top"""
  104:         self.moveObjectsToBottom([id])
  105:         if REQUEST:
  106:             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
  107:           
  108:     def getOwner(self):
  109:         """get Owner as string"""
  110:         return self.owner
  111:     
  112:     def changeBasketForm(self):
  113:         """form for changing the basket"""
  114:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasket.zpt')).__of__(self)
  115:         return pt()
  116: 
  117:     def changeBasket(self,title,comment,shortDescription,publicationStatus=None,username=None,accessGroups=None,RESPONSE=None,target=None):
  118:         '''
  119:         init the basket
  120:         @param title: title of the basket
  121:         @param comment: description of the basket
  122:         @param owner: user object describing the owner
  123:         @param publication_status: one of publicationStatus if restricted, optional parameter accessGroups has to be set
  124:         @param aaccessGroups: default value is none, contains list of groups which are allowed to access this basket
  125:         '''
  126:          #TODO:what happens in username does not exists
  127:         #find username
  128:         owner=username
  129:     
  130:         self.title=title
  131:         self.comment=comment
  132:         if owner:
  133:             self.owner=owner
  134:         if publicationStatus:
  135:             self.publicationStatus=publicationStatus
  136:         if accessGroups:
  137:             self.accessGroups=accessGroups
  138:         self.shortDescription=shortDescription
  139:     
  140:         
  141:         if RESPONSE is not None:
  142:             if target:
  143:                 RESPONSE.redirect(target)
  144:             else:
  145:                 RESPONSE.redirect('manage_main')
  146:                 
  147:     def index_html(self):
  148:         """generische ansicht"""
  149: 
  150:         if hasattr(self,"BasketMain_template"):
  151:             obj=getattr(self,"BasketMain_template")
  152:             return obj()
  153:         else:
  154:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_template_standard.zpt')).__of__(self)
  155:             pt.content_type="text/html"
  156:             return pt()
  157:     
  158:     def manageBasket(self):
  159:         """manage the basket"""
  160:         
  161:         if hasattr(self,"BasketMain_manage_template"):
  162:             obj=getattr(self,"BasketMain_manage_template")
  163:             return obj()
  164:         else:
  165:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_manage_template_standard.zpt')).__of__(self)
  166:             pt.content_type="text/html"
  167:             return pt()
  168:     
  169:     def isAuthorized(self,role="read"):
  170:         """check whether actual user is authorized"""
  171:         #TODO implement isAuthorized to do type, read or edit
  172:         return True
  173:       
  174:     def getActualUserName(self):
  175:         """get username of actual user"""
  176:         return self.REQUEST['AUTHENTICATED_USER'].getUserName()
  177:         
  178:     def getObjects(self):
  179:         """"get objects"""
  180:         return [getattr(self,x['id']) for x in self._objects]
  181:    
  182:     def numberOfObjects(self):
  183:         """anzahl der elemente im basket"""
  184:         return len(self._objects)
  185:     
  186:     def changeBasketComments(self,REQUEST):
  187:         """Change comment of basket elements"""
  188:         form=REQUEST.form
  189:         
  190:         for key in form.keys():
  191:             splitted=key.split("_")
  192:             objects=self.ZopeFind(self,obj_ids=[splitted[0]])
  193:             if len(objects)>0:
  194:                 objects[0][1].comment=form[key]
  195:    
  196:         if REQUEST:
  197:             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")  
  198:               
  199: 
  200:     def selectThisBasketAsCurrent(self,REQUEST=None):
  201:         """select this basket for further work"""
  202:         REQUEST.RESPONSE.setCookie('vlp_basket',self.getId(),path="/")
  203:         
  204:         if REQUEST:
  205:             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
  206:         
  207:     def getCurrentBasket(self):
  208:         """select this basket for further work"""
  209:         return self.REQUEST.cookies.get('vlp_basket',None)
  210:     
  211:     def generateNewObject(self,type,link,title='',comment='',REQUEST=None):
  212:         """generate a new object in the basket"""
  213:         
  214:         if type=="xref":
  215: 
  216:             splitted=urllib.unquote(link).split("?")
  217:             if len(splitted)>1:
  218:                 #assumes references id is contained in the url as parameter id=
  219:                 params=cgi.parse_qs(splitted[1])
  220:                 xref=params.get('id',None)
  221:                 return False
  222:             else:
  223:                 #addumes link contains only the reference id
  224:                 xref=link
  225: 
  226:             id=self.getNewId()
  227:             title=""
  228: 
  229:             if xref is None:
  230:                 #no parameter id
  231:                 return False
  232:             manage_addBasketXRef(self,str(id),title,comment,xref)
  233:         
  234:         if REQUEST:
  235:             REQUEST.RESPONSE.redirect(REQUEST['HTTP_REFERER'])
  236:         else:
  237:             return True
  238: 
  239: def manage_addBasketForm(self):
  240:     """form for adding a basket"""
  241:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
  242:     return pt()
  243: 
  244: def manage_addBasket(self,id,title,comment,username,publicationStatus,accessGroups=None,RESPONSE=None):
  245:     """add a basket object"""
  246:     #TODO:what happens in username does not exists
  247:     #find username
  248:     owner=username
  249:     
  250:     newObj=Basket(id,title,comment,owner,publicationStatus,accessGroups=None)
  251:     
  252:     self._setObject(id,newObj)
  253:     
  254:     if RESPONSE is not None:
  255:         RESPONSE.redirect('manage_main')
  256:      
  257: class BasketBasis(SimpleItem):
  258:     """basic class for baskets"""
  259:     
  260:     security=ClassSecurityInfo()
  261:     
  262:     manage_options=SimpleItem.manage_options+(
  263:         {'label':'manage main','action':'changeBasketBasisForm'},
  264:         )
  265:     
  266:     def __init__(self,id,title,comment):
  267:         '''
  268:         init basket basis
  269:         @param id: id
  270:         @param title: title
  271:         @param comment commentar:
  272:         '''
  273:         self.id=id
  274:         self.title=title
  275:         self.comment=comment
  276:         
  277:     def changeBasketBasisForm(self):
  278:         """form for changing the basket"""
  279:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketBasis.zpt')).__of__(self)
  280:         return pt()
  281:     
  282:     def changeBasketBasis(self,title,comment,RESPONSE=None):
  283:         '''
  284:         init the basket
  285:         @param title: title of the basket
  286:         @param comment: description of the basket
  287:         '''
  288:         
  289:         self.title=title
  290:         self.comment=comment
  291:         
  292:         if RESPONSE is not None:
  293:             RESPONSE.redirect('manage')
  294:     
  295:     def linkToObject(self):
  296:         """generate url to open the resource, has to be implemented in the different objects, generic return None"""
  297:         return None
  298:     
  299:     def content_html(self,type):
  300:         """generische ausgabe des objectes als html"""
  301:         if hasattr(self,type+"_template"):
  302:             obj=getattr(self,type+"_template")
  303:             return obj()
  304:         else:
  305:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','%s_template_standard.zpt'%type)).__of__(self)
  306:             pt.content_type="text/html"
  307:             return pt()
  308:     
  309: class BasketXRef(BasketBasis):
  310:     """class for internal references based on xrefs"""
  311:     
  312:     security=ClassSecurityInfo()
  313:     meta_type="BasketXRef"
  314: 
  315:     manage_options=BasketBasis.manage_options+(
  316:         {'label':'manage xref','action':'changeBasketXRefForm'},
  317:         )
  318:     
  319:     def changeBasketXRefForm(self):
  320:         """form for changing the basket"""
  321:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketXRef.zpt')).__of__(self)
  322:         return pt()
  323:     
  324:     def changeBasketXRef(self,xref,RESPONSE=None):
  325:         '''
  326:         change the basket
  327:         @param xref: reference
  328:         '''
  329:         
  330:         self.xref=xref
  331:         
  332:         if RESPONSE is not None:
  333:             RESPONSE.redirect('manage')
  334:       
  335:     def linkToObject(self):
  336:         """generate url to open the resource"""
  337:         return refBasis%self.xref
  338:     
  339:     def content_html(self):
  340:         """format object as html fragment"""
  341:         
  342:         type=self.xref[0:3]
  343:         return BasketBasis.content_html(self,"BasketXRef_%s"%type)
  344:     
  345: def manage_addBasketXRefForm(self):
  346:     """form for adding a basket"""
  347:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketXRef.zpt')).__of__(self)
  348:     return pt()
  349: 
  350: def manage_addBasketXRef(self,id,title,comment,xref,RESPONSE=None):
  351:     """add a basketXRef object"""
  352:     
  353:     
  354:     newObj=BasketXRef(id,title,comment)
  355:     newObj.xref=xref
  356:     
  357:     self._setObject(id,newObj)
  358:     
  359:     if RESPONSE is not None:
  360:         RESPONSE.redirect('manage_main')
  361:        
  362: class BasketInternalLink(BasketBasis):
  363:     """class for internal referencens based on links"""
  364:     
  365:     security=ClassSecurityInfo()
  366:     meta_type="BasketInternalLink"
  367:     
  368:     manage_options=BasketBasis.manage_options+(
  369:         {'label':'manage internal link','action':'changeBasketInternalLinkForm'},
  370:         )
  371:  
  372:     def changeBasketInternalLinkForm(self):
  373:         """form for changing the basket"""
  374:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketInternalLink.zpt')).__of__(self)
  375:         return pt()
  376:     
  377:     def changeBasketInternalLink(self,link,linkText,RESPONSE=None):
  378:         '''
  379:         change the Internallink
  380:         @param link: reference
  381:         @param linkText: reference
  382:         '''
  383:         
  384:         self.link=link
  385:         self.linkText=linkText
  386:         
  387:         if RESPONSE is not None:
  388:             RESPONSE.redirect('manage')
  389:     
  390:     def content_html(self):
  391:         """format object as html fragment"""
  392:         
  393:         return BasketBasis.content_html(self,"BasketInternalLink")
  394:     
  395:     def linkToObject(self):
  396:         """link to the object (internalLink)"""
  397:         return self.link
  398:     
  399: def manage_addBasketInternalLinkForm(self):
  400:     """form for adding a basket"""
  401:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketInternalLink.zpt')).__of__(self)
  402:     return pt()
  403: 
  404: def manage_addBasketInternalLink(self,id,title,comment,link,linkText,RESPONSE=None):
  405:     """add a basketXRef object"""
  406:     
  407:     
  408:     newObj=BasketInternalLink(id,title,comment)
  409:     newObj.link=link
  410:     newObj.linkText=linkText
  411:     
  412:     self._setObject(id,newObj)
  413:     
  414:     if RESPONSE is not None:
  415:         RESPONSE.redirect('manage_main')
  416:        
  417:     
  418: class BasketExternalLink(BasketBasis):
  419:     """class for external links"""
  420:     
  421:     security=ClassSecurityInfo()
  422:     meta_type="BasketExternalLink"
  423:     
  424:     manage_options=BasketBasis.manage_options+(
  425:         {'label':'manage internal link','action':'changeBasketExternalLinkForm'},
  426:         )
  427:  
  428:     def changeBasketExternalLinkForm(self):
  429:         """form for changing the basket"""
  430:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketExternalLink.zpt')).__of__(self)
  431:         return pt()
  432:     
  433:     def changeBasketExternalLink(self,link,linkText,RESPONSE=None):
  434:         '''
  435:         change the Externallink
  436:         @param link: reference
  437:         @param linkText: reference
  438:         '''
  439:         
  440:         self.link=link
  441:         self.linkText=linkText
  442:         
  443:         if RESPONSE is not None:
  444:             RESPONSE.redirect('manage')
  445:     
  446:     def content_html(self):
  447:         """format object as html fragment"""
  448:         
  449:         return BasketBasis.content_html(self,"BasketExternalLink")
  450:     
  451:     def linkToObject(self):
  452:         """link to the object (externalLink)"""
  453:         return self.link
  454: 
  455: def manage_addBasketExternalLinkForm(self):
  456:     """form for adding a basket"""
  457:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketExternalLink.zpt')).__of__(self)
  458:     return pt()
  459: 
  460: def manage_addBasketExternalLink(self,id,title,comment,link,linkText,RESPONSE=None):
  461:     """add a basket external link object"""
  462:     
  463:     newObj=BasketExternalLink(id,title,comment)
  464:     newObj.link=link
  465:     newObj.linkText=linkText
  466:     
  467:     self._setObject(id,newObj)
  468:     
  469:     if RESPONSE is not None:
  470:         RESPONSE.redirect('manage_main')
  471:        
  472:     
  473: class BasketText(BasketBasis):
  474:     """class for text elements in baskets"""
  475:     
  476:     security=ClassSecurityInfo()
  477:     meta_type="BasketText"
  478: 
  479:     def content_html(self):
  480:         """format object as html fragment"""
  481:         return "" # text has no content
  482:         #return BasketBasis.content_html(self,"BasketText")
  483:     
  484: def manage_addBasketTextForm(self):
  485:     """form for adding a basket"""
  486:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketText.zpt')).__of__(self)
  487:     return pt()
  488: 
  489: def manage_addBasketText(self,id,title,comment,RESPONSE=None):
  490:     """add a basketXRef object"""
  491:     
  492:     
  493:     newObj=BasketText(id,title,comment)
  494:     
  495:     self._setObject(id,newObj)
  496:     
  497:     if RESPONSE is not None:
  498:         RESPONSE.redirect('manage_main')
  499:        
  500:     
  501:     
  502: