version 1.3, 2005/12/08 17:11:31
|
version 1.4, 2006/02/02 19:19:24
|
Line 6 import os.path
|
Line 6 import os.path
|
import os |
import os |
from types import * |
from types import * |
import urlparse |
import urlparse |
|
from OFS.OrderedFolder import OrderedFolder |
|
from OFS.SimpleItem import SimpleItem |
|
import time |
|
|
class Basket(Folder): |
|
"""shopping basket""" |
|
|
class Basket_old(Folder): |
|
"""shopping basket - alte fassung """ |
|
|
meta_type="Basket" |
meta_type="Basket" |
_v_stack={} |
_v_stack={} |
Line 19 class Basket(Folder):
|
Line 24 class Basket(Folder):
|
if len(founds)>0: |
if len(founds)>0: |
return founds[0].getObject().absolute_url() |
return founds[0].getObject().absolute_url() |
|
|
else: #assume version |
else: #assume version number |
splitted=objId.split("_") |
splitted=objId.split("_") |
founds=self.CDLICatalog.search({'path':splitted[1]}) |
founds=self.CDLICatalog.search({'path':splitted[1]}) |
return founds[0].getObject().absolute_url()+'/'+objId |
return founds[0].getObject().absolute_url()+'/'+objId |
Line 89 class Basket(Folder):
|
Line 94 class Basket(Folder):
|
user=self.REQUEST.SESSION.get('basketUser',None) |
user=self.REQUEST.SESSION.get('basketUser',None) |
|
|
if not user: |
if not user: |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','authorizeBasketUser.zpt')).__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self) |
return pt() |
return pt() |
else: |
else: |
baskets=self.ZopeFind(self,obj_ids=[user]) |
baskets=self.ZopeFind(self,obj_ids=[user]) |
Line 103 class Basket(Folder):
|
Line 108 class Basket(Folder):
|
return pt() |
return pt() |
|
|
|
|
def manage_addBasketForm(self): |
def manage_addBasket_oldForm(self): |
"""add the basket form""" |
"""add the basket form""" |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self) |
return pt() |
return pt() |
|
|
def manage_addBasket(self,id,title,RESPONSE=None): |
def manage_addBasket_old(self,id,title,RESPONSE=None): |
"""add the basket""" |
"""add the basket""" |
ob=Basket() |
ob=Basket() |
|
|
Line 121 def manage_addBasket(self,id,title,RESPO
|
Line 126 def manage_addBasket(self,id,title,RESPO
|
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
|
|
class BasketObject(Folder): |
class BasketObject_old(Folder): |
"""Basket Object""" |
"""Basket Object - alte fassung""" |
|
|
meta_type="basketObject" |
meta_type="basketObject" |
def __init__(self): |
def __init__(self): |
Line 220 class BasketObject(Folder):
|
Line 225 class BasketObject(Folder):
|
self.REQUEST.RESPONSE.write(ret) |
self.REQUEST.RESPONSE.write(ret) |
|
|
|
|
def manage_addBasketObjectForm(self): |
def manage_addBasket_oldObjectForm(self): |
"""add form""" |
"""add form""" |
pass |
pass |
|
|
def manage_addBasketObject(self,id,title='',RESPONSE=None): |
def manage_addBasket_oldObject(self,id,title='',RESPONSE=None): |
"""add""" |
"""add""" |
|
|
ob=BasketObject() |
ob=BasketObject() |
Line 237 def manage_addBasketObject(self,id,title
|
Line 242 def manage_addBasketObject(self,id,title
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect('manage_main') |
RESPONSE.redirect('manage_main') |
|
|
|
|
|
class CDLIBasketContainer(OrderedFolder): |
|
"""contains the baskets""" |
|
|
|
|
|
|
|
meta_type="CDLIBasketContainer" |
|
|
|
|
|
def uploadBasket_html(self,basketId='0'): |
|
"""upload an atf file, html form""" |
|
basketId=str(basketId) |
|
if not basketId=='0': |
|
basketName=getattr(self.basketContainer,basketId).title |
|
else: |
|
basketName="" |
|
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self) |
|
return pt(basketId=basketId,basketName=basketName) |
|
|
|
|
|
|
|
def index_html(self): |
|
"""stanadard ansicht""" |
|
ext=self.ZopeFind(self,obj_ids=["index.html"]) |
|
if ext: |
|
return ext[0][1]() |
|
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self) |
|
return pt() |
|
|
|
def getStorageFolderRoot(self): |
|
"""root des storage folders""" |
|
return self.cdli_main |
|
|
|
def __init__(self,id,title): |
|
""" init basket container""" |
|
self.id=id |
|
self.title=title |
|
|
|
|
|
def getBaskets(self,sortField='title'): |
|
"""get all baskets files""" |
|
|
|
def sortName(x,y): |
|
return cmp(x[1].title.lower(),y[1].title.lower()) |
|
|
|
def sortDate(x,y): |
|
return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime()) |
|
|
|
|
|
def sortComment(x,y): |
|
|
|
|
|
|
|
try: |
|
xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower() |
|
except: |
|
xc='ZZZZZZZZZZZZZ'.lower() |
|
try: |
|
yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower() |
|
except: |
|
yc='ZZZZZZZZZZZZZ'.lower() |
|
|
|
|
|
if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()): |
|
|
|
try: |
|
xc=x[1].getLastVersion().getComment().lower() |
|
except: |
|
xc='ZZZZZZZZZZZZZ'.lower() |
|
|
|
if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()): |
|
try: |
|
yc=y[1].getLastVersion().getComment().lower() |
|
except: |
|
yc='ZZZZZZZZZZZZZ'.lower() |
|
|
|
|
|
return cmp(xc,yc) |
|
|
|
def sortAuthor(x,y): |
|
|
|
return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower()) |
|
|
|
baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket']) |
|
|
|
|
|
if sortField=='title': |
|
baskets.sort(sortName) |
|
elif sortField=='date': |
|
baskets.sort(sortDate) |
|
elif sortField=='author': |
|
baskets.sort(sortAuthor) |
|
elif sortField=='comment': |
|
baskets.sort(sortComment) |
|
|
|
return baskets |
|
|
|
|
|
|
|
def getNewId(self): |
|
"""createIds""" |
|
last=getattr(self,'last',0) |
|
last +=1 |
|
while len(self.ZopeFind(self,obj_ids=[str(last)]))>0: |
|
last+=1 |
|
|
|
self.last=last |
|
return last |
|
|
|
def setActiveBasket(self,basketId): |
|
"""store active basketId in a cookie""" |
|
self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/") |
|
|
|
def getActiveBasket(self): |
|
"""get active basket from cookie""" |
|
|
|
id= self.REQUEST.cookies.get('CDLIActiveBasket',None) |
|
obj=getattr(self,id,None) |
|
return obj |
|
def getActualUserName(self): |
|
"""get name of the actualuser""" |
|
return str(self.REQUEST['AUTHENTICATED_USER']) |
|
|
|
|
|
def addBasket(self,newBasketName): |
|
"""add a new basket""" |
|
|
|
ob=manage_addCDLIBasket(self,newBasketName) |
|
return ob |
|
|
|
def storeInBasket(self,ids,submit,newBasketName=None,RESPONSE=None,REQUEST=None): |
|
"""store it""" |
|
|
|
if type(ids) is not ListType: |
|
ids=[ids] |
|
|
|
if submit=="store in new basket": |
|
basketRet=self.addBasket(newBasketName) |
|
self.setActiveBasket(basketRet.getId()) |
|
basket=getattr(self,basketRet.getId()) |
|
elif submit=="store in active basket": |
|
basket=self.getActiveBasket() |
|
|
|
basket.addObjects(ids) |
|
back=self.REQUEST['HTTP_REFERER'] |
|
|
|
if RESPONSE: |
|
RESPONSE.redirect(back) |
|
|
|
|
|
def manage_addCDLIBasketContainerForm(self): |
|
"""add the CDLIBasketContainer form""" |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self) |
|
return pt() |
|
|
|
def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None): |
|
"""add the basket""" |
|
ob=CDLIBasketContainer(id,title) |
|
|
|
self._setObject(id, ob) |
|
|
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
|
|
class CDLIBasket(Folder): |
|
"""basket""" |
|
|
|
meta_type="CDLIBasket" |
|
|
|
def getFile(self,obj): |
|
return obj[1] |
|
|
|
def getFileLastVersion(self,obj): |
|
return obj[0] |
|
|
|
def isActual(self,obj): |
|
"""teste ob im basket die aktuelle version ist""" |
|
actualNo=obj[1].getLastVersion().getVersionNumber() |
|
storedNo=obj[0].getVersionNumber() |
|
if actualNo==storedNo: |
|
return True |
|
else: |
|
return False |
|
|
|
def history(self): |
|
"""history""" |
|
|
|
ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"]) |
|
if ext: |
|
return getattr(self,ext[0][1].getId())() |
|
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self) |
|
return pt() |
|
|
|
def getStorageFolderRoot(self): |
|
"""root des storage folders""" |
|
return self.aq_parent.cdli_main |
|
|
|
def __init__(self,id,title,shortDescription="",comment=""): |
|
"""init a CDLIBasket""" |
|
|
|
self.id=id |
|
self.title=title |
|
self.shortDescription=shortDescription |
|
self.comment=comment |
|
|
|
|
|
|
|
def getLastVersion(self): |
|
"""hole letzte version""" |
|
ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])] |
|
ids.sort() |
|
if len(ids)==0: |
|
return None |
|
else: |
|
ob=getattr(self,str(ids[-1])) |
|
return ob |
|
|
|
def getVersions(self): |
|
"""get versions""" |
|
versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"]) |
|
return versions |
|
|
|
|
|
|
|
def addObjects(self,ids,deleteOld=None): |
|
"""generate a new version of the basket with objects added""" |
|
|
|
lastVersion=self.getLastVersion() |
|
|
|
if lastVersion is None: |
|
oldContent=[] |
|
else: |
|
oldContent=lastVersion.basketContent[0:] |
|
|
|
if deleteOld: |
|
oldContent=[] |
|
|
|
newContent=[] |
|
|
|
for id in ids: |
|
founds=self.CDLICatalog.search({'title':id}) |
|
print id,founds |
|
for found in founds: |
|
if found.getObject() not in oldContent: |
|
#TODO: was passiert wenn, man eine Object dazufgt, das schon da ist aber eine neuere version |
|
newContent.append((found.getObject().getLastVersion(),found.getObject())) |
|
|
|
|
|
content=oldContent+newContent |
|
|
|
user=self.getActualUserName() |
|
|
|
ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content) |
|
|
|
|
|
|
|
def deleteObjects(self,ids,RESPONSE=None): |
|
"""delete objects""" |
|
#TODO: implement delete Objects |
|
|
|
def manage_addCDLIBasketForm(self): |
|
"""add the CDLIBasketContainer form""" |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self) |
|
return pt() |
|
|
|
def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None): |
|
"""add the basket""" |
|
|
|
id=str(self.getNewId()) |
|
|
|
ob=CDLIBasket(id,title,shortDescription,comment) |
|
|
|
self._setObject(id, ob) |
|
|
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
else: |
|
return ob |
|
|
|
class CDLIBasketVersion(SimpleItem): |
|
"""version of a basket""" |
|
|
|
meta_type="CDLIBasketVersion" |
|
|
|
def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None): |
|
"""download all selected files in one file""" |
|
|
|
ret="" |
|
lockedObjects={} |
|
|
|
|
|
if lock: |
|
|
|
if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User': |
|
|
|
return "please login first" |
|
|
|
#check if a locked object exist in the basket. |
|
lockedObjects={} |
|
for object in self.basketContent: |
|
|
|
if not object[1].lockedBy=="": |
|
lockedObjects[object[1].title]=repr(object[1].lockedBy) |
|
|
|
|
|
keys=lockedObjects.keys() |
|
|
|
|
|
if len(keys)>0 and (not procedure): |
|
self.REQUEST.SESSION['lockedObjects']=lockedObjects |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self) |
|
return pt() |
|
|
|
elif not procedure: #keine fails gesperrt dann alle donwloaden |
|
procedure="downloadAll" |
|
|
|
|
|
for object in self.basketContent: |
|
|
|
if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']): |
|
ret+=object[0].data |
|
|
|
if lock and object[1].lockedBy=='': |
|
object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER'] |
|
|
|
basket_name=self.aq_parent.title+"_V"+self.getId() |
|
|
|
#write basketname to header of atf file |
|
ret="#atf basket %s\n"%basket_name+ret |
|
|
|
self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name) |
|
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream") |
|
length=len(ret) |
|
self.REQUEST.RESPONSE.setHeader("Content-Length",length) |
|
self.REQUEST.RESPONSE.write(ret) |
|
|
|
|
|
def numberOfItems(self): |
|
"""return anzahl der elemente im basket""" |
|
return len(self.basketContent) |
|
|
|
def getTime(self): |
|
"""getTime""" |
|
#return self.bobobase_modification_time().ISO() |
|
|
|
if hasattr(self,'time'): |
|
return time.strftime("%Y-%m-%d %H:%M:%S",self.time) |
|
elif hasattr(self,'timefixed'): |
|
return self.timefixed |
|
else: |
|
setattr(self,'timefixed',self.bobobase_modification_time().ISO()) |
|
return self.bobobase_modification_time().ISO() |
|
|
|
def getContent(self): |
|
"""get Basket Content""" |
|
return self.basketContent |
|
|
|
|
|
def __init__(self,id,user,comment="",basketContent=[]): |
|
""" init a basket version""" |
|
self.id=id |
|
self.coment=comment |
|
self.basketContent=basketContent[0:] |
|
self.user=user |
|
self.time=time.localtime() |
|
|
|
def getUser(self): |
|
"""get user""" |
|
return self.user |
|
|
|
def getComment(self): |
|
"""get Comment""" |
|
return self.comment |
|
|
|
def index_html(self): |
|
"""view the basket""" |
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self) |
|
return pt() |
|
|
|
def getObjUrl(self,result): |
|
"""getUrl of the version of the object""" |
|
objId=result[1].getTitle() |
|
founds=self.CDLICatalog.search({'title':objId}) |
|
if len(founds)>0: |
|
return founds[0].getObject().absolute_url() |
|
|
|
else: #assume version number |
|
splitted=objId.split("_") |
|
founds=self.CDLICatalog.search({'path':splitted[1]}) |
|
return founds[0].getObject().absolute_url()+'/'+objId |
|
|
|
def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None): |
|
"""add a version""" |
|
|
|
#check for already existing versions |
|
|
|
lastVersion=self.getLastVersion() |
|
if lastVersion is None: |
|
newId=str(1) |
|
else: |
|
newId=str(int(lastVersion.getId())+1) |
|
|
|
ob=CDLIBasketVersion(newId,user,comment,basketContent) |
|
|
|
self._setObject(newId, ob) |
|
|
|
if RESPONSE is not None: |
|
RESPONSE.redirect('manage_main') |
|
else: |
|
return ob |
|
|
class CDLIFileObject(versionedFileObject): |
class CDLIFileObject(versionedFileObject): |
"""CDLI file object""" |
"""CDLI file object""" |
|
|
Line 360 def manage_addCDLIFile(self,id,title,loc
|
Line 779 def manage_addCDLIFile(self,id,title,loc
|
|
|
def splitatf(fh,dir=None): |
def splitatf(fh,dir=None): |
"""split it""" |
"""split it""" |
|
ret=None |
nf=None |
nf=None |
for line in fh.readlines(): |
for line in fh.readlines(): |
|
#check if basket name is in the first line |
|
if line.find("#atf basket")>=0: |
|
ret=line.replace('#atf basket ','') |
|
else: |
if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile |
if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile |
if nf: |
if nf: |
nf.close() #close last file |
nf.close() #close last file |
Line 373 def splitatf(fh,dir=None):
|
Line 795 def splitatf(fh,dir=None):
|
if dir: |
if dir: |
filename=os.path.join(dir,filename) |
filename=os.path.join(dir,filename) |
nf=file(filename,"w") |
nf=file(filename,"w") |
|
if nf: |
nf.write(line) |
nf.write(line) |
|
|
nf.close() |
nf.close() |
fh.close() |
fh.close() |
|
return ret.split('_')[0],len(os.listdir(dir)) |
|
|
class CDLIFileFolder(versionedFileFolder): |
class CDLIFileFolder(versionedFileFolder): |
"""CDLI folder""" |
"""CDLI File Folder""" |
|
|
meta_type="CDLI Folder" |
meta_type="CDLI Folder" |
filesMetaType=['CDLI file'] |
filesMetaType=['CDLI file'] |
folderMetaType=['CDLI Folder'] |
folderMetaType=['CDLI Folder'] |
default_catalog='CDLICatalog' |
default_catalog='CDLICatalog' |
|
|
def uploadATF(self,upload,RESPONSE=None): |
def getVersionNumbersFromIds(self,ids): |
|
"""get the numbers of the current versions of documents described by their ids""" |
|
|
|
ret=[] |
|
searchStr=" OR ".join(ids) |
|
|
|
founds=self.CDLICatalog.search({'path':searchStr}) |
|
|
|
for found in founds: |
|
lastVersion=found.getObject().getLastVersion() |
|
ret.append((found.getId,lastVersion)) |
|
|
|
return ret |
|
|
|
|
|
def uploadATF(self,upload,basketId=0,RESPONSE=None): |
"""upload an atf file""" |
"""upload an atf file""" |
#TODO: add comments |
#TODO: add comments |
#TODO: finish uploadATF |
#TODO: finish uploadATF |
|
basketId=str(basketId) |
|
|
|
|
|
|
dir=mkdtemp() |
dir=mkdtemp() |
changed=[] |
changed=[] |
errors=[] |
errors=[] |
newPs=[] |
newPs=[] |
splitatf(upload,dir) |
basketNameFromFile, numberOfFiles=splitatf(upload,dir) |
|
if basketId == '0': |
|
basketNameFromId="" |
|
basketLen=0 |
|
else: |
|
basketNameFromId=getattr(self.basketContainer,basketId).title |
|
basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems() |
|
|
|
|
for fn in os.listdir(dir): |
for fn in os.listdir(dir): |
founds=self.CDLICatalog.search({'path':fn}) |
founds=self.CDLICatalog.search({'title':fn}) |
|
|
if len(founds)==0: |
if len(founds)==0: |
newPs.append(fn) |
newPs.append(fn) |
|
|
Line 420 class CDLIFileFolder(versionedFileFolder
|
Line 870 class CDLIFileFolder(versionedFileFolder
|
self.REQUEST.SESSION['tmpdir']=dir |
self.REQUEST.SESSION['tmpdir']=dir |
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self) |
return pt(changed=changed,errors=errors,dir=dir,newPs=newPs) |
return pt(changed=changed,errors=errors,dir=dir,newPs=newPs,basketLen=basketLen,numberOfFiles=numberOfFiles, |
|
basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId) |
|
|
def uploadATFfinally(self,procedure,comment="",unlock=None,RESPONSE=None): |
def uploadATFfinally(self,procedure,comment="",basketId='0',unlock=None,RESPONSE=None): |
"""upload the files""" |
"""upload the files""" |
|
|
if procedure=="uploadchanged": |
if procedure=="uploadchanged": |
Line 466 class CDLIFileFolder(versionedFileFolder
|
Line 917 class CDLIFileFolder(versionedFileFolder
|
|
|
founds[0].getObject().lockedBy="" |
founds[0].getObject().lockedBy="" |
|
|
|
if not (basketId =='0'): |
|
basket=getattr(self.basketFolder,basketId) |
|
ids=os.listdir(self.REQUEST.SESSION['tmpdir']) |
|
basket.addObjects(ids,deleteOld=True) |
|
|
if RESPONSE is not None: |
if RESPONSE is not None: |
RESPONSE.redirect(self.aq_parent.absolute_url()) |
RESPONSE.redirect(self.aq_parent.absolute_url()) |
|
|