[BACK]Return to basket.py CVS log [TXT] [DIR] Up to [Repository] / basket

Diff for /basket/basket.py between versions 1.3 and 1.15

version 1.3, 2006/03/19 03:26:56 version 1.15, 2009/04/21 07:57:00
Line 8  import cgi Line 8  import cgi
   
 from OFS.OrderedFolder import OrderedFolder  from OFS.OrderedFolder import OrderedFolder
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
   from OFS.Image import File
   
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
 from AccessControl.User import UserFolder  from AccessControl.User import UserFolder
Line 21  from Globals import Persistent, package_ Line 22  from Globals import Persistent, package_
 from Acquisition import Implicit  from Acquisition import Implicit
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   
   
 from groups import manage_addGroupFolder  from groups import manage_addGroupFolder
   
   from Products.ECHO_content.ECHO_helpers import unicodify
   
 refBasis="http://vlp.mpiwg-berlin.mpg.de/references?id=%s"   refBasis="http://vlp.mpiwg-berlin.mpg.de/references?id=%s" 
   
 basketMetatypes=['BasketXRef','BasketInternalLink','BasketExternalLink','BasketText']  basketMetatypes=['BasketXRef','BasketInternalLink','BasketExternalLink','BasketText','BasketFile']
   
 #basis url for references  #basis url for references
   
Line 37  class BasketBasis(OrderedFolder): Line 39  class BasketBasis(OrderedFolder):
     """Basis class for BasketFolder and Baskets"""      """Basis class for BasketFolder and Baskets"""
           
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
       
       def content_html(self,type):
           """generische ausgabe des objectes als html"""
           if hasattr(self,type+"_template"):
               obj=getattr(self,type+"_template")
               return obj()
           else:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','%s_template_standard.zpt'%type)).__of__(self)
               pt.content_type="text/html"
               return pt()
       
       def checkPermission(self,modus):
           """check permission"""
           if modus=='open':
               return True
           elif modus=='private':
               return self.groupFolder.isMemberOf('admin')
           elif modus=='admin':
               return self.groupFolder.isMemberOf('admin')
           elif modus=='edit':
               return (self.groupFolder.isMemberOf('editor') or self.groupFolder.isMemberOf('admin'))
           elif modus=='publish':
               return self.groupFolder.isMemberOf('publish')
           elif modus=='authorized':
               if self.getActualUserName().lower() == "anonymous user":
                   return False
               else:
                   return True
               
        
     def getNewId(self):      def getNewId(self):
         """createIds"""          """createIds"""
         last=getattr(self,'last',0)          last=getattr(self,'last',0)
Line 46  class BasketBasis(OrderedFolder): Line 78  class BasketBasis(OrderedFolder):
           
         return last          return last
           
       def addBasketFile(self,REQUEST=None,fileUpload=None,comment=None,title=""):
           """add a file to the basket"""
           if fileUpload==None:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketFile.zpt')).__of__(self)
               pt.content_type="text/html"
               return pt()
           else:
               id=self.getNewId()
               if title=="":
                   title=fileUpload.filename
                   
               manage_addBasketFile(self,id,title,comment,fileUpload)
               if REQUEST:
                   REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
       
     def addBasketText(self,REQUEST=None):      def addBasketText(self,REQUEST=None):
         """add a text"""          """add a text"""
         id=self.getNewId()          id=self.getNewId()
         manage_addBasketText(self,str(id),'','',RESPONSE=None)          manage_addBasketText(self,str(id),'','',RESPONSE=None)
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+str(id))
           
     def addBasketExternalLink(self,REQUEST=None):      def addBasketExternalLink(self,REQUEST=None):
         """add an external link"""          """add an external link"""
Line 59  class BasketBasis(OrderedFolder): Line 106  class BasketBasis(OrderedFolder):
                   
         manage_addBasketExternalLink(self,str(id),"","","","",RESPONSE=None)          manage_addBasketExternalLink(self,str(id),"","","","",RESPONSE=None)
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+str(id))
                   
     def deleteObject(self,id,REQUEST=None):      def deleteObject(self,id,REQUEST=None):
         """delete object"""          """delete object"""
Line 71  class BasketBasis(OrderedFolder): Line 118  class BasketBasis(OrderedFolder):
         """move id one up"""          """move id one up"""
         self.moveObjectsUp([id], 1)          self.moveObjectsUp([id], 1)
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+id)
           
     def moveDown(self,id,REQUEST=None):      def moveDown(self,id,REQUEST=None):
         """move id one up"""          """move id one up"""
         self.moveObjectsDown([id], 1)          self.moveObjectsDown([id], 1)
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+id)
                           
     def moveTop(self,id,REQUEST=None):      def moveTop(self,id,REQUEST=None):
         """move to top"""          """move to top"""
         self.moveObjectsToTop([id])          self.moveObjectsToTop([id])
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+id)
       
     def moveBottom(self,id,REQUEST=None):      def moveBottom(self,id,REQUEST=None):
         """move to top"""          """move to top"""
         self.moveObjectsToBottom([id])          self.moveObjectsToBottom([id])
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")              REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+id)
           
     security.declareProtected('View','getOwner')      security.declareProtected('View','getOwner')
                       
     def getOwner(self):      def getOwner(self):
         """get Owner as string"""          """get Owner as string"""
         return self.owner          return unicodify(self.owner)
           
     def isAuthorized(self,role="read"):      def getTitle(self):
         """check whether actual user is authorized"""          """get title"""
         #TODO replace occurences with checkPermission          return unicodify(self.title)
         return True  
           
     def getActualUserName(self):      def getActualUserName(self):
         """get username of actual user"""          """get username of actual user"""
Line 108  class BasketBasis(OrderedFolder): Line 154  class BasketBasis(OrderedFolder):
                   
     def getObjects(self):      def getObjects(self):
         """"get objects"""          """"get objects"""
         return [getattr(self,x['id']) for x in self._objects]          return self.objectValues()
           #return [getattr(self,x['id']) for x in self._objects]
         
     def numberOfObjects(self):      def numberOfObjects(self):
         """anzahl der elemente im basket"""          """anzahl der elemente im basket"""
         return len(self._objects)          return len(self._objects)
           
       
 class BasketFolder(BasketBasis):  class BasketFolder(BasketBasis):
     """Folder for Baskets"""      """Folder for Baskets"""
           
Line 126  class BasketFolder(BasketBasis): Line 174  class BasketFolder(BasketBasis):
         ret=[]          ret=[]
                   
         if mode=='open':          if mode=='open':
              
             for object in self.getObjects():              for object in self.getObjects():
                         
                 if object.publicationStatus=='open':                  if object.publicationStatus=='open':
Line 134  class BasketFolder(BasketBasis): Line 181  class BasketFolder(BasketBasis):
             return ret              return ret
         elif mode=='open_intern':          elif mode=='open_intern':
             print "open_intern"              print "open_intern"
             if self.groupFolder.isMemberOf('user'):              if self.checkPermission('authorized'):
                 print "---public"  
                 for object in self.getObjects():                  for object in self.getObjects():
                     print object.getId(),object.publicationStatus                      if object.publicationStatus=='open_intern' or object.publicationStatus=='open':
                     if object.publicationStatus=='open_intern':  
                         ret.append(object)                          ret.append(object)
                 return ret                  return ret
             else:              else:
Line 157  class BasketFolder(BasketBasis): Line 202  class BasketFolder(BasketBasis):
     def getCurrentBasket(self):      def getCurrentBasket(self):
         """select this basket for further work"""          """select this basket for further work"""
             
         return self.REQUEST.cookies.get('vlp_basket',None)          id=self.REQUEST.cookies.get('vlp_basket',None)
       if id:  
           return getattr(self,id,None)
       else:
           return None
           
       
     def index_html(self,mode='open'):      def index_html(self,mode='open'):
         """generische ansicht"""          """generische ansicht"""
Line 165  class BasketFolder(BasketBasis): Line 215  class BasketFolder(BasketBasis):
         #check if user has right for other modi          #check if user has right for other modi
                   
         if hasattr(self,"BasketFolder_template"):          if hasattr(self,"BasketFolder_template"):
             obj=getattr(self,"BaskeFolder_template")              obj=getattr(self,"BasketFolder_template")
             return obj()              return obj(mode=mode)
         else:          else:
             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketFolder_template_standard.zpt')).__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketFolder_template_standard.zpt')).__of__(self)
             pt.content_type="text/html"              pt.content_type="text/html"
Line 236  class Basket(BasketBasis): Line 286  class Basket(BasketBasis):
         {'label':'manage main','action':'changeBasketForm'},          {'label':'manage main','action':'changeBasketForm'},
         )          )
           
     def checkPermission(self,modus):   
         """check permission"""      def saveButton(self,actualId):
         if modus=='open':          """return the save button"""
             return True          ret="""
         elif modus=='private':          <a class="editLink" style="cursor:pointer"
             return self.groupFolder.isMemberOf('admin')                      onClick="forms.changeSetContents.actualId.value='%s';forms.changeSetContents.submit();">save</a> -
         elif modus=='admin':      
             return self.groupFolder.isMemberOf('admin')          """%actualId
         elif modus=='edit':          return ret
             return self.groupFolder.isMemberOf('edit')  
         elif modus=='publish':  
             return self.groupFolder.isMemberOf('publish')  
             
     def manageUserRights_html(self):      def manageUserRights_html(self):
         """manage user rights"""          """manage user rights"""
Line 262  class Basket(BasketBasis): Line 309  class Basket(BasketBasis):
     
     def getBasketObjects(self):      def getBasketObjects(self):
         """get all basket objects"""          """get all basket objects"""
   #         objs=self.getObjects()
   #         ret=[]
   #         for x in objs:
   #             if x.meta_type in basketMetatypes:
   #                ret.append(x)
   #         return ret
           return self.objectValues(basketMetatypes)
                   
         objs=self.getObjects()  
         ret=[]  
         for x in objs:  
             if x.meta_type in basketMetatypes:  
                ret.append(x)  
         return ret  
           
     def checkRef(self,xref):      def checkRef(self,xref):
         """check if XRef is already in Basket"""          """check if XRef is already in Basket"""
Line 298  class Basket(BasketBasis): Line 346  class Basket(BasketBasis):
         self.shortDescription=shortDescription          self.shortDescription=shortDescription
                   
                   
       def getComment(self):
           """get the comment"""
           return unicodify(self.comment)
           
   
       def getShortDescription(self):
           """get the short description"""
           return unicodify(self.shortDescription)
     
     def getTitle(self):  
         """print name"""  
         return self.title  
                   
     security.declareProtected('Manage','changeBasketForm')      security.declareProtected('Manage','changeBasketForm')
     def changeBasketForm(self):      def changeBasketForm(self):
Line 375  class Basket(BasketBasis): Line 428  class Basket(BasketBasis):
   
         
         if REQUEST:          if REQUEST:
             REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")                REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket#"+form.get('actualId',''))  
                               
   
     def selectThisBasketAsCurrent(self,REQUEST=None):      def selectThisBasketAsCurrent(self,REQUEST=None):
Line 410  class Basket(BasketBasis): Line 463  class Basket(BasketBasis):
             manage_addBasketXRef(self,str(id),title,comment,xref)              manage_addBasketXRef(self,str(id),title,comment,xref)
                   
         if REQUEST:          if REQUEST:
             import random              #import random
             rd=random.random()              #rd=random.random()
             REQUEST.RESPONSE.redirect(REQUEST['HTTP_REFERER']+'&-dummy='+str(rd))              urlSplit=REQUEST['HTTP_REFERER'].split("?")
               if len(urlSplit)>1:
                   parsed=cgi.parse_qs(urlSplit[1])
                   parsed['-link']=link
                   qs=urllib.urlencode(parsed,doseq=True)
                   
               else:
                   qs=""
                   
               REQUEST.RESPONSE.redirect(urlSplit[0]+"?"+qs)
         else:          else:
             return True              return True
   
Line 434  def manage_addBasket(self,id,title,comme Line 496  def manage_addBasket(self,id,title,comme
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
             
 class BasketBasis(SimpleItem):  class BasketObject(SimpleItem):
     """basic class for baskets"""      """basic class for baskets"""
           
     #security=ClassSecurityInfo()      #security=ClassSecurityInfo()
Line 454  class BasketBasis(SimpleItem): Line 516  class BasketBasis(SimpleItem):
         self.title=title          self.title=title
         self.comment=comment          self.comment=comment
                   
       def getTitle(self):
           """get the title"""
           return unicodify(self.title)
   
       def getComment(self):
           """get the comment"""
           return unicodify(self.comment)
   
           
     def changeBasketBasisForm(self):      def changeBasketBasisForm(self):
         """form for changing the basket"""          """form for changing the basket"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketBasis.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketBasis.zpt')).__of__(self)
Line 486  class BasketBasis(SimpleItem): Line 557  class BasketBasis(SimpleItem):
             pt.content_type="text/html"              pt.content_type="text/html"
             return pt()              return pt()
           
 class BasketXRef(BasketBasis):  class BasketFile(BasketObject,File):
       """class for fileupload"""
       meta_type="BasketFile"
       
       def __init__(self,id,title,comment,content_type='',precondition=''):
           """init"""
           self.id=id
           self.title=title
           self.comment=comment
           self.content_type=content_type
           self.precondition=precondition
           
       
       def download(self):
           """download the file"""
   
           self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.title)
           self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
      
           self.content_type="application/octet-stream"
       try:
               self.REQUEST.RESPONSE.write(self.data)
           except:
           try:
               self.REQUEST.RESPONSE.write(str(self.data))
           except:
               self.REQUEST.RESPONSE.write(repr(self.data))
   
       def upDateFile(self,fileUpload=None,comment=None,title="",REQUEST=None):
           """update file"""
           
           if fileUpload==None:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','upDateBasketFile.zpt')).__of__(self)
               pt.content_type="text/html"
               return pt()
           else:
               
               if title=="":
                   title=fileUpload.filename
               
               self.title=title    
               if fileUpload:
                   self.manage_upload(fileUpload)
       
               if comment:
                   self.comment=comment
                   
               if REQUEST:
                   REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
       
       def content_html(self):
           """format object as html fragment"""
           
           
           return BasketObject.content_html(self,"BasketFile")
       
   def manage_addBasketFile(self,id,title,comment,fileUpload,content_type='',precondition='',REQUEST=None):
       """add a basket file"""
       
       id=str(id)
       title=str(title)
       content_type=str(content_type)
       precondition=str(precondition)
   
       #id, title = cookId(id, title, file)
   
       self=self.this()
   
       # First, we create the file without data:
       self._setObject(id, BasketFile(id,title,comment,content_type, precondition))
   
       # Now we "upload" the data.  By doing this in two steps, we
       # can use a database trick to make the upload more efficient.
       if fileUpload:
           self._getOb(id).manage_upload(fileUpload)
       if content_type:
           self._getOb(id).content_type=content_type
   
       if REQUEST is not None:
           REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
           
   class BasketXRef(BasketObject):
     """class for internal references based on xrefs"""      """class for internal references based on xrefs"""
           
     #security=ClassSecurityInfo()      #security=ClassSecurityInfo()
Line 520  class BasketXRef(BasketBasis): Line 672  class BasketXRef(BasketBasis):
         """format object as html fragment"""          """format object as html fragment"""
                   
         type=self.xref[0:3]          type=self.xref[0:3]
         return BasketBasis.content_html(self,"BasketXRef_%s"%type)          return BasketObject.content_html(self,"BasketXRef_%s"%type)
           
 def manage_addBasketXRefForm(self):  def manage_addBasketXRefForm(self):
     """form for adding a basket"""      """form for adding a basket"""
Line 539  def manage_addBasketXRef(self,id,title,c Line 691  def manage_addBasketXRef(self,id,title,c
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                 
 class BasketInternalLink(BasketBasis):  class BasketInternalLink(BasketObject):
     """class for internal referencens based on links"""      """class for internal referencens based on links"""
           
     #security=ClassSecurityInfo()      #security=ClassSecurityInfo()
     meta_type="BasketInternalLink"      meta_type="BasketInternalLink"
           
     manage_options=BasketBasis.manage_options+(      manage_options=BasketObject.manage_options+(
         {'label':'manage internal link','action':'changeBasketInternalLinkForm'},          {'label':'manage internal link','action':'changeBasketInternalLinkForm'},
         )          )
     
Line 570  class BasketInternalLink(BasketBasis): Line 722  class BasketInternalLink(BasketBasis):
     def content_html(self):      def content_html(self):
         """format object as html fragment"""          """format object as html fragment"""
                   
         return BasketBasis.content_html(self,"BasketInternalLink")          return BasketObject.content_html(self,"BasketInternalLink")
           
     def linkToObject(self):      def linkToObject(self):
         """link to the object (internalLink)"""          """link to the object (internalLink)"""
Line 595  def manage_addBasketInternalLink(self,id Line 747  def manage_addBasketInternalLink(self,id
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                 
           
 class BasketExternalLink(BasketBasis):  class BasketExternalLink(BasketObject):
     """class for external links"""      """class for external links"""
           
     #security=ClassSecurityInfo()      #security=ClassSecurityInfo()
     meta_type="BasketExternalLink"      meta_type="BasketExternalLink"
           
     manage_options=BasketBasis.manage_options+(      manage_options=BasketObject.manage_options+(
         {'label':'manage internal link','action':'changeBasketExternalLinkForm'},          {'label':'manage internal link','action':'changeBasketExternalLinkForm'},
         )          )
     
       def getLinkText(self):
           """get the link text"""
           return unicodify(self.linkText)
    
     def changeBasketExternalLinkForm(self):      def changeBasketExternalLinkForm(self):
         """form for changing the basket"""          """form for changing the basket"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketExternalLink.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketExternalLink.zpt')).__of__(self)
Line 626  class BasketExternalLink(BasketBasis): Line 782  class BasketExternalLink(BasketBasis):
     def content_html(self):      def content_html(self):
         """format object as html fragment"""          """format object as html fragment"""
                   
         return BasketBasis.content_html(self,"BasketExternalLink")          return BasketObject.content_html(self,"BasketExternalLink")
           
     def linkToObject(self):      def linkToObject(self):
         """link to the object (externalLink)"""          """link to the object (externalLink)"""
Line 650  def manage_addBasketExternalLink(self,id Line 806  def manage_addBasketExternalLink(self,id
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                 
           
 class BasketText(BasketBasis):  class BasketText(BasketObject):
     """class for text elements in baskets"""      """class for text elements in baskets"""
           
     #security=ClassSecurityInfo()      #security=ClassSecurityInfo()
Line 669  def manage_addBasketTextForm(self): Line 825  def manage_addBasketTextForm(self):
 def manage_addBasketText(self,id,title,comment,RESPONSE=None):  def manage_addBasketText(self,id,title,comment,RESPONSE=None):
     """add a basketXRef object"""      """add a basketXRef object"""
           
       
     newObj=BasketText(id,title,comment)      newObj=BasketText(id,title,comment)
           
     self._setObject(id,newObj)      self._setObject(id,newObj)
           
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
          
       
       
        
   
Removed from v.1.3  
changed lines
  Added in v.1.15

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>