"""CDLI extensions of the filearchive"""
from Products.versionedFile.versionedFile import *
from Products.ZCatalog.CatalogPathAwareness import CatalogAware
from tempfile import mkstemp
import os.path
import os
from types import *
class Basket(Folder):
"""shopping basket"""
meta_type="Basket"
_v_stack={}
def storeAllLink(self,results):
"""erzeuge link zum speicher aller results"""
nr=self.REQUEST['_ZopeId']
if results:
self._v_stack[nr]=[x.getObject().getId() for x in results]
return self.absolute_url()+"/storeAll?id="+nr
def storeAll(self,id):
"""store all"""
try:
results=self._v_stack[id]
except:
#TODO: write expired page
return "expired"
return self.storeInBasketForm(results)
def storeInBasketForm(self,ids):
""" store an object form"""
if type(ids) is not ListType:
ids=[ids]
self.REQUEST.SESSION['ids']=ids[0:]
self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)
return pt()
def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):
"""store it"""
if not ids:
ids=REQUEST.SESSION['ids']
self.REQUEST.SESSION['basketUser']=username
baskets=self.ZopeFind(self,obj_ids=[username])
if len(baskets)>0:
basket=baskets[0][1]
else:
manage_addBasketObject(self,username)
basket=self._getOb(username)
basket.addObjects(ids)
back=self.REQUEST.SESSION.get('BACKLINK', None)
if RESPONSE:
RESPONSE.redirect(back)
def showBasket(self,user=None,set=None,RESPONSE=None):
"""show the basket"""
if user:
self.REQUEST.SESSION['basketUser']=user
if not user and not set:
user=self.REQUEST.SESSION.get('basketUser',None)
if not user:
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','authorizeBasketUser.zpt')).__of__(self)
return pt()
else:
baskets=self.ZopeFind(self,obj_ids=[user])
if len(baskets)>0:
RESPONSE.redirect(baskets[0][1].absolute_url())
return True
else:
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)
return pt()
def manage_addBasketForm(self):
"""add the basket form"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
return pt()
def manage_addBasket(self,id,title,RESPONSE=None):
"""add the basket"""
ob=Basket()
ob.id=str(id)
ob.title=title
self._setObject(id, ob)
ob=self._getOb(id)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class BasketObject(Folder):
"""Basket Object"""
def __init__(self):
"""init basket object"""
self.contents=[]
def numberOfItems(self):
"""return anzahl der elemente im basket"""
return len(self.contents)
def addObjects(self,ids):
"""addObjects"""
for id in ids:
founds=self.CDLICatalog.search({'path':id})
for found in founds:
if found.getObject() not in self.contents:
tm=self.contents[0:]
tm.append(found.getObject())
self.contents=tm[0:]
return True
def index_html(self):
"""view the basket"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
return pt()
def deleteObjects(self,ids,RESPONSE=None):
"""delete objects"""
list = self.contents[0:]
for content in list:
if content.getId() in ids:
self.contents.remove(content)
if RESPONSE:
RESPONSE.redirect(self.absolute_url())
def downloadObjectsAsOneFile(self,REQUEST):
"""download all selected files in one file"""
ret=""
for object in self.contents:
ret+=object.getLastVersion().data
self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
len=len(ret)
self.REQUEST.RESPONSE.setHeader("Content-Length",len)
self.REQUEST.RESPONSE.write(ret)
def manage_addBasketObjectForm(self):
"""add form"""
pass
def manage_addBasketObject(self,id,title='',RESPONSE=None):
"""add"""
ob=BasketObject()
ob.id=str(id)
ob.title=title
self._setObject(id, ob)
ob=self._getOb(id)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class CDLIFile(versionedFile,CatalogAware):
"""CDLI file"""
meta_type="CDLI file"
default_catalog='CDLICatalog'
def manage_addCDLIFileForm(self):
"""interface for adding the OSAS_root"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
return pt()
def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
"""add the OSAS_root"""
newObj=CDLIFile(id,title,lockedBy,author)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class CDLIFileObject(versionedFileObject):
"""CDLI file object"""
meta_type="CDLI File Object"
def view(self):
"""view file"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
return pt()
manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
REQUEST=None):
"""Add a new File object.
Creates a new File object 'id' with the contents of '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, CDLIFileObject(id,title,'',content_type, precondition))
self._getOb(id).versionComment=str(vC)
self._getOb(id).time=time.localtime()
setattr(self._getOb(id),'author',author)
# Now we "upload" the data. By doing this in two steps, we
# can use a database trick to make the upload more efficient.
if file:
self._getOb(id).manage_upload(file)
if content_type:
self._getOb(id).content_type=content_type
if REQUEST is not None:
REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
class CDLIFileFolder(versionedFileFolder):
"""CDLI folder"""
meta_type="CDLI Folder"
filesMetaType=['CDLI file']
folderMetaType=['CDLI Folder']
default_catalog='CDLICatalog'
def uploadATF(self,upload,RESPONSE):
"""upload an atf file"""
mks
def findObjectsFromList(self,upload,RESPONSE):
"""findObjectsFromList (, TAB oder LINE separated)"""
txt=upload.read()
txt=txt.replace(",","\n")
txt=txt.replace("\t","\n")
idsTmp=txt.split("\n")
ids=[]
for id in idsTmp: # make sure that no empty lines
idTmp=id.lstrip().rstrip()
if len(idTmp)>0:
ids.append(idTmp)
#self.REQUEST.SESSION['ids']=" OR ".join(ids)
RESPONSE.redirect("filelist.html?path=%s"%" OR ".join(ids))
def createAllFilesAsSingleFile(self,RESPONSE=None):
"""download all files"""
def sortF(x,y):
return cmp(x[0],y[0])
catalog=getattr(self,self.default_catalog)
#tf,tfilename=mkstemp()
list=[(x.getId,x) for x in catalog()]
list.sort(sortF)
RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
RESPONSE.setHeader("Content-Type","application/octet-stream")
for l in list:
obj=l[1].getObject()
if obj.meta_type=="CDLI file":
#os.write(tf,obj.getLastVersion().data)
if RESPONSE:
RESPONSE.write(obj.getLastVersion().data)
#os.close(tf)
#RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
return True
def downloadFile(self,fn):
"""download fn - not used yet"""
self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
self.REQUEST.RESPONSE.write(file(fn).read())
def hasParent(self):
"""returns true falls subfolder"""
if self.aq_parent.meta_type in self.folderMetaType:
return True
else:
return False
def getFolders(self):
"""get all subfolders"""
ret=[]
folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
for folder in folders:
ret.append((folder[1],
len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
len(self.ZopeFind(folder[1],obj_metatypes=self.filesMetaType))
))
return ret
def getFolders_OLD(self):
"""get all subfolders"""
ret=[]
folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
for folder in folders:
ret.append((folder[1],
len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
len(getattr(self,self.default_catalog)({'path':folder[0]}))
))
return ret
def index_html(self):
"""main"""
ext=self.ZopeFind(self,obj_ids=["index.html"])
if ext:
return ext[0][1]()
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
return pt()
def importFiles(self,comment="",author="" ):
"""import files"""
folderName="/Users/dwinter/Documents/workspace/cdli/atf"
files=os.listdir(folderName)
for f in files:
folder=f[0:3]
f2=f[0:5]
obj=self.ZopeFind(self,obj_ids=[folder])
if not obj:
manage_addCDLIFileFolder(self,folder,folder)
fobj=getattr(self,folder)
else:
fobj=obj[0][1]
obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
if not obj2:
manage_addCDLIFileFolder(fobj,f2,f2)
fobj2=getattr(fobj,f2)
else:
fobj2=obj2[0][1]
print f
file2=file(os.path.join(folderName,f))
id=f
manage_addCDLIFile(fobj2,f,'','')
id=f
ob=fobj2._getOb(f)
ob.title=id
manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')
return "ok"
manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
def manage_addCDLIFileFolder(self, id, title='',
createPublic=0,
createUserF=0,
REQUEST=None):
"""Add a new Folder object with id *id*.
If the 'createPublic' and 'createUserF' parameters are set to any true
value, an 'index_html' and a 'UserFolder' objects are created respectively
in the new folder.
"""
ob=CDLIFileFolder()
ob.id=str(id)
ob.title=title
self._setObject(id, ob)
ob=self._getOb(id)
checkPermission=getSecurityManager().checkPermission
if createUserF:
if not checkPermission('Add User Folders', ob):
raise Unauthorized, (
'You are not authorized to add User Folders.'
)
ob.manage_addUserFolder()
if REQUEST is not None:
return self.manage_main(self, REQUEST, update_menu=1)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>