###objects to store and manage objects in baskets

import os
import os.path
import urllib
import cgi


from OFS.OrderedFolder import OrderedFolder
from OFS.SimpleItem import SimpleItem

from AccessControl import ClassSecurityInfo
from AccessControl.User import UserFolder
from Globals import InitializeClass
from Globals import DTMLFile
import Globals
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Globals import Persistent, package_home
from Acquisition import Implicit
from Products.ZCatalog.CatalogPathAwareness import CatalogAware

refBasis="http://vlp.mpiwg-berlin.mpg.de/references?id=%s" 
#basis url for references

publicationStatus=['private','restricted','open','published'] 
# private only access for the owner, restricted only for users in accessGroup, open open for everyone, published occurs in basket list

class Basket(OrderedFolder):
    """Basket class"""
    
    meta_type="basket"
    
    security=ClassSecurityInfo()
    
    manage_options=OrderedFolder.manage_options+(
        {'label':'manage main','action':'changeBasketForm'},
        )
    
    def __init__(self,id,title,comment,owner,publicationStatus,shortDescription,accessGroups=None):
        '''
        init the basket
        @param id: id
        @param title: title of the basket
        @param comment: description of the basket
        @param shortDescription: short description of the basket for the overviewList
        @param owner: user object describing the owner
        @param publication_status: one of publicationStatus if restricted, optional parameter accessGroups has to be set
        @param aaccessGroups: default value is none, contains list of groups which are allowed to access this basket
        '''
        
        self.id=id
        self.title=title
        self.comment=comment
        self.owner=owner
        self.publicationStatus=publicationStatus
        self.accessGroups=accessGroups
        self.shortDecription=shortDescription
        
    security.declareProtected('View','getOwner')
    
    def getNewId(self):
        """createIds"""
        last=getattr(self,'last',0)
        last +=1
        while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
            last+=1
        return last
        
    def addBasketText(self,REQUEST=None):
        """add a text"""
        id=self.getNewId()
        manage_addBasketText(self,str(id),'','',RESPONSE=None)
        if REQUEST:
            REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
    
    def deleteObject(self,id,REQUEST=None):
        """delete object"""
        self.manage_delObjects([id])
        if REQUEST:
            REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
    
    def moveUp(self,id,REQUEST=None):
        """move id one up"""
        self.moveObjectsUp([id], 1)
        if REQUEST:
            REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
    
    def moveDown(self,id,REQUEST=None):
        """move id one up"""
        self.moveObjectsDown([id], 1)
        if REQUEST:
            REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
            
    def moveTop(self,id,REQUEST=None):
        """move to top"""
        self.moveObjectsToTop([id])
        if REQUEST:
            REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
  
    def moveBottom(self,id,REQUEST=None):
        """move to top"""
        self.moveObjectsToBottom([id])
        if REQUEST:
            REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
          
    def getOwner(self):
        """get Owner as string"""
        return self.owner
    
    def changeBasketForm(self):
        """form for changing the basket"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasket.zpt')).__of__(self)
        return pt()

    def changeBasket(self,title,comment,shortDescription,publicationStatus=None,username=None,accessGroups=None,RESPONSE=None,target=None):
        '''
        init the basket
        @param title: title of the basket
        @param comment: description of the basket
        @param owner: user object describing the owner
        @param publication_status: one of publicationStatus if restricted, optional parameter accessGroups has to be set
        @param aaccessGroups: default value is none, contains list of groups which are allowed to access this basket
        '''
         #TODO:what happens in username does not exists
        #find username
        owner=username
    
        self.title=title
        self.comment=comment
        if owner:
            self.owner=owner
        if publicationStatus:
            self.publicationStatus=publicationStatus
        if accessGroups:
            self.accessGroups=accessGroups
        self.shortDescription=shortDescription
    
        
        if RESPONSE is not None:
            if target:
                RESPONSE.redirect(target)
            else:
                RESPONSE.redirect('manage_main')
                
    def index_html(self):
        """generische ansicht"""

        if hasattr(self,"BasketMain_template"):
            obj=getattr(self,"BasketMain_template")
            return obj()
        else:
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_template_standard.zpt')).__of__(self)
            pt.content_type="text/html"
            return pt()
    
    def manageBasket(self):
        """manage the basket"""
        
        if hasattr(self,"BasketMain_manage_template"):
            obj=getattr(self,"BasketMain_manage_template")
            return obj()
        else:
            pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketMain_manage_template_standard.zpt')).__of__(self)
            pt.content_type="text/html"
            return pt()
    
    def isAuthorized(self,role="read"):
        """check whether actual user is authorized"""
        #TODO implement isAuthorized to do type, read or edit
        return True
      
    def getActualUserName(self):
        """get username of actual user"""
        return self.REQUEST['AUTHENTICATED_USER'].getUserName()
        
    def getObjects(self):
        """"get objects"""
        return [getattr(self,x['id']) for x in self._objects]
   
    def numberOfObjects(self):
        """anzahl der elemente im basket"""
        return len(self._objects)
    
    def changeBasketComments(self,REQUEST):
        """Change comment of basket elements"""
        form=REQUEST.form
        
        for key in form.keys():
            splitted=key.split("_")
            objects=self.ZopeFind(self,obj_ids=[splitted[0]])
            if len(objects)>0:
                objects[0][1].comment=form[key]
   
        if REQUEST:
            REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")  
              

    def selectThisBasketAsCurrent(self,REQUEST=None):
        """select this basket for further work"""
        REQUEST.RESPONSE.setCookie('vlp_basket',self.getId(),path="/")
        
        if REQUEST:
            REQUEST.RESPONSE.redirect(self.absolute_url()+"/manageBasket")
        
    def getCurrentBasket(self):
        """select this basket for further work"""
        return self.REQUEST.cookies.get('vlp_basket',None)
    
    def generateNewObject(self,type,link,title='',comment='',REQUEST=None):
        """generate a new object in the basket"""
        
        if type=="xref":

            splitted=urllib.unquote(link).split("?")
            if len(splitted)>1:
                #assumes references id is contained in the url as parameter id=
                params=cgi.parse_qs(splitted[1])
                xref=params.get('id',None)
                return False
            else:
                #addumes link contains only the reference id
                xref=link

            id=self.getNewId()
            title=""

            if xref is None:
                #no parameter id
                return False
            manage_addBasketXRef(self,str(id),title,comment,xref)
        
        if REQUEST:
            REQUEST.RESPONSE.redirect(REQUEST['HTTP_REFERER'])
        else:
            return True

def manage_addBasketForm(self):
    """form for adding a basket"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
    return pt()

def manage_addBasket(self,id,title,comment,username,publicationStatus,accessGroups=None,RESPONSE=None):
    """add a basket object"""
    #TODO:what happens in username does not exists
    #find username
    owner=username
    
    newObj=Basket(id,title,comment,owner,publicationStatus,accessGroups=None)
    
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')
     
class BasketBasis(SimpleItem):
    """basic class for baskets"""
    
    security=ClassSecurityInfo()
    
    manage_options=SimpleItem.manage_options+(
        {'label':'manage main','action':'changeBasketBasisForm'},
        )
    
    def __init__(self,id,title,comment):
        '''
        init basket basis
        @param id: id
        @param title: title
        @param comment commentar:
        '''
        self.id=id
        self.title=title
        self.comment=comment
        
    def changeBasketBasisForm(self):
        """form for changing the basket"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketBasis.zpt')).__of__(self)
        return pt()
    
    def changeBasketBasis(self,title,comment,RESPONSE=None):
        '''
        init the basket
        @param title: title of the basket
        @param comment: description of the basket
        '''
        
        self.title=title
        self.comment=comment
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage')
    
    def linkToObject(self):
        """generate url to open the resource, has to be implemented in the different objects, generic return None"""
        return None
    
    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()
    
class BasketXRef(BasketBasis):
    """class for internal references based on xrefs"""
    
    security=ClassSecurityInfo()
    meta_type="BasketXRef"

    manage_options=BasketBasis.manage_options+(
        {'label':'manage xref','action':'changeBasketXRefForm'},
        )
    
    def changeBasketXRefForm(self):
        """form for changing the basket"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketXRef.zpt')).__of__(self)
        return pt()
    
    def changeBasketXRef(self,xref,RESPONSE=None):
        '''
        change the basket
        @param xref: reference
        '''
        
        self.xref=xref
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage')
      
    def linkToObject(self):
        """generate url to open the resource"""
        return refBasis%self.xref
    
    def content_html(self):
        """format object as html fragment"""
        
        type=self.xref[0:3]
        return BasketBasis.content_html(self,"BasketXRef_%s"%type)
    
def manage_addBasketXRefForm(self):
    """form for adding a basket"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketXRef.zpt')).__of__(self)
    return pt()

def manage_addBasketXRef(self,id,title,comment,xref,RESPONSE=None):
    """add a basketXRef object"""
    
    
    newObj=BasketXRef(id,title,comment)
    newObj.xref=xref
    
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')
       
class BasketInternalLink(BasketBasis):
    """class for internal referencens based on links"""
    
    security=ClassSecurityInfo()
    meta_type="BasketInternalLink"
    
    manage_options=BasketBasis.manage_options+(
        {'label':'manage internal link','action':'changeBasketInternalLinkForm'},
        )
 
    def changeBasketInternalLinkForm(self):
        """form for changing the basket"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketInternalLink.zpt')).__of__(self)
        return pt()
    
    def changeBasketInternalLink(self,link,linkText,RESPONSE=None):
        '''
        change the Internallink
        @param link: reference
        @param linkText: reference
        '''
        
        self.link=link
        self.linkText=linkText
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage')
    
    def content_html(self):
        """format object as html fragment"""
        
        return BasketBasis.content_html(self,"BasketInternalLink")
    
    def linkToObject(self):
        """link to the object (internalLink)"""
        return self.link
    
def manage_addBasketInternalLinkForm(self):
    """form for adding a basket"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketInternalLink.zpt')).__of__(self)
    return pt()

def manage_addBasketInternalLink(self,id,title,comment,link,linkText,RESPONSE=None):
    """add a basketXRef object"""
    
    
    newObj=BasketInternalLink(id,title,comment)
    newObj.link=link
    newObj.linkText=linkText
    
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')
       
    
class BasketExternalLink(BasketBasis):
    """class for external links"""
    
    security=ClassSecurityInfo()
    meta_type="BasketExternalLink"
    
    manage_options=BasketBasis.manage_options+(
        {'label':'manage internal link','action':'changeBasketExternalLinkForm'},
        )
 
    def changeBasketExternalLinkForm(self):
        """form for changing the basket"""
        pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeBasketExternalLink.zpt')).__of__(self)
        return pt()
    
    def changeBasketExternalLink(self,link,linkText,RESPONSE=None):
        '''
        change the Externallink
        @param link: reference
        @param linkText: reference
        '''
        
        self.link=link
        self.linkText=linkText
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage')
    
    def content_html(self):
        """format object as html fragment"""
        
        return BasketBasis.content_html(self,"BasketExternalLink")
    
    def linkToObject(self):
        """link to the object (externalLink)"""
        return self.link

def manage_addBasketExternalLinkForm(self):
    """form for adding a basket"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketExternalLink.zpt')).__of__(self)
    return pt()

def manage_addBasketExternalLink(self,id,title,comment,link,linkText,RESPONSE=None):
    """add a basket external link object"""
    
    newObj=BasketExternalLink(id,title,comment)
    newObj.link=link
    newObj.linkText=linkText
    
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')
       
    
class BasketText(BasketBasis):
    """class for text elements in baskets"""
    
    security=ClassSecurityInfo()
    meta_type="BasketText"

    def content_html(self):
        """format object as html fragment"""
        return "" # text has no content
        #return BasketBasis.content_html(self,"BasketText")
    
def manage_addBasketTextForm(self):
    """form for adding a basket"""
    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasketText.zpt')).__of__(self)
    return pt()

def manage_addBasketText(self,id,title,comment,RESPONSE=None):
    """add a basketXRef object"""
    
    
    newObj=BasketText(id,title,comment)
    
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')