from OFS.Folder import Folder
from OFS.Image import File
from OFS.Image import cookId
from Globals import DTMLFile, InitializeClass,package_home
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from AccessControl import getSecurityManager
from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from AccessControl import ClassSecurityInfo
from threading import Thread
import shutil
import tempfile
import os.path
import time
try:
from Products.ECHO_content.ECHO_collection import ECHO_basis
except:
print "ECHO Elements not imported"
class ECHO_basis:
"""leer"""
manage_options=()
def sortv(x,y):
return cmp(x[0],y[0])
tdir = "/tmp/testia"
class generateDownloadZip:
"""generateDownloadSet"""
def __init__(self,folderObject,url):
"""init downloadzip"""
self.folder=folderObject
self.done=None
self.response=""
self.url=url
def __call__(self):
"""call generate download zip"""
storeTempDir=tempfile.tempdir
tempfile.tempdir=tdir
tmpPath=tempfile.mktemp()
tmpZip=tempfile.mktemp()+".gtz"
tmpFn=os.path.split(tmpZip)[1]
if not os.path.exists(tempfile.tempdir):
os.mkdir(tempfile.tempdir)
if not os.path.exists(tmpPath):
os.mkdir(tmpPath)
self.response="<h3>1. step: gettung the files</h3>"
for files in self.folder.ZopeFind(self.folder,obj_metatypes=['versionedFile']):
lastV=files[1].getLastVersion()
self.response+=str("<p>Get File: %s<br>\n"%lastV.title)
savePath=os.path.join(tmpPath,lastV.title)
fh=file(savePath,"w")
fh.write(lastV.data)
fh.close()
self.response+="<h3>2. step: creating the downloadable file</h3>"
self.response+="<p>Create gtar<br>"
self.response+="<p>This can take a while....<br>\n"
fh=os.popen2("tar zcvf %s %s/*"%(tmpZip,tmpPath),1)[1]
self.response+="<br>"
for c in fh.read():
self.response+=c
if c==")":
self.response+="<br>\n"
shutil.rmtree(tmpPath)
self.response+="<p>finished<br>\n"
len=os.stat(tmpZip)[6]
downloadUrl=self.url+"/downloadSet"
self.response+="""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len)
self.response+="""<p>The file will be stored for a while, you can download it later, the URL is:</p>
<p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn)
self.done=True
def getResult(self):
"""get result"""
return self.response
def isDone(self):
if self.done:
return True
else:
return False
class versionedFileFolder(Folder,ECHO_basis):
"""Folder with versioned files"""
meta_type = "versionedFileFolder"
security= ClassSecurityInfo()
security.declareProtected('AUTHENTICATED_USER','addFileForm')
if ECHO_basis:
optTMP= Folder.manage_options+ECHO_basis.manage_options
else:
optTMP= Folder.manage_options
manage_options =optTMP+(
{'label':'Generate Index.html','action':'generateIndexHTML'},
{'label':'Generate history_template.html','action':'generateHistoryHTML'},
{'label':'Import Folder','action':'importFolderForm'},
)
def importFolderForm(self):
"""form fuer folder import"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importFolderForm.zpt')).__of__(self)
return pt()
def importFolder(self,path,comment="",author=None,lockedBy=None,RESPONSE=None):
"""importiere inhalt eines folders"""
for fileName in os.listdir(path):
if os.path.isfile(os.path.join(path,fileName)):
manage_addVersionedFile(self,fileName,'','')
id=fileName
ob=self._getOb(fileName)
ob.title=id
file2=file(os.path.join(path,fileName))
obj=ob.manage_addVersionedFileObject(id,comment,author,file2,content_type='')
if RESPONSE:
RESPONSE.redirect(self.REQUEST['URL1'])
zipThreads={}
zipThreads2={}
def refreshTxt(self):
"""txt fuer refresh"""
tn=self.REQUEST.SESSION['threadName']
return """ 2;url=%s?repeat=%s """%(self.absolute_url()+"/exportFolder",tn)
def exportFolder(self,repeat=None):
"""exportiert alle akutellen files des folders"""
threadName=repeat
if not threadName or threadName=="":
threadStart=generateDownloadZip(self,self.absolute_url())
thread=Thread(target=threadStart)
thread.start()
self.zipThreads[thread.getName()[0:]]=threadStart
self.zipThreads2[thread.getName()[0:]]=thread
self.REQUEST.SESSION['threadName']=thread.getName()[0:]
wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
if wait_template:
return wait_template[0][1]()
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
return pt()
else:
self.REQUEST.SESSION['threadName']=threadName
if (self.zipThreads[threadName].getResult()==None):
wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
if wait_template:
return wait_template[0][1]()
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
return pt()
else:
if self.zipThreads[threadName].isDone():
self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
self.zipThreads2[threadName].join()
del(self.zipThreads2[threadName])
del(self.zipThreads[threadName])
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
return pt()
else:
self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
self.REQUEST.SESSION['threadName']=threadName
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)
return pt()
def downloadSet(self,fn):
"""download prepared set"""
filename=os.path.join(tdir,fn)
self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"donloadFileFolder.tgz")
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
len=os.stat(filename)[6]
self.REQUEST.RESPONSE.setHeader("Content-Length",len)
images=file(filename).read()
self.REQUEST.RESPONSE.write(images)
self.REQUEST.RESPONSE.close()
def helpDownload(self):
"""download help"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','helpDownload')).__of__(self)
return pt()
def generateIndexHTML(self,RESPONSE=None):
"""lege standard index.html an"""
if not self.ZopeFind(self,obj_ids=['index.html']):
zt=ZopePageTemplate('index.html')
self._setObject('index.html',zt)
default_content_fn = os.path.join(package_home(globals()),
'zpt/versionFileFolderMain.zpt')
text = open(default_content_fn).read()
zt.pt_edit(text, 'text/html')
else:
return "already exists!"
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def generateHistoryHTML(self,RESPONSE=None):
"""lege standard index.html an"""
if not self.ZopeFind(self,obj_ids=['history_template.html']):
zt=ZopePageTemplate('history_template.html')
self._setObject('history_template.html',zt)
default_content_fn = os.path.join(package_home(globals()),
'zpt/versionHistory.zpt')
text = open(default_content_fn).read()
zt.pt_edit(text, 'text/html')
else:
return "already exists!"
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def getVersionedFiles(self,sortField='title'):
"""get all versioned 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().getVComment().lower()
except:
xc='ZZZZZZZZZZZZZ'.lower()
if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
try:
yc=y[1].getLastVersion().getVComment().lower()
except:
yc='ZZZZZZZZZZZZZ'.lower()
return cmp(xc,yc)
def sortAuthor(x,y):
return cmp(x[1].getLastVersion().lastEditor().lower(),y[1].getLastVersion().lastEditor().lower())
versionedFiles=self.ZopeFind(self,obj_metatypes=['versionedFile'])
if sortField=='title':
versionedFiles.sort(sortName)
elif sortField=='date':
versionedFiles.sort(sortDate)
elif sortField=='author':
versionedFiles.sort(sortAuthor)
elif sortField=='comment':
versionedFiles.sort(sortComment)
return versionedFiles
def header_html(self):
"""zusätzlicher header"""
ext=self.ZopeFind(self,obj_ids=["header.html"])
if ext:
return ext[0][1]()
else:
return ""
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','versionFileFolderMain')).__of__(self)
return pt()
def addFileForm(self):
"""add a file"""
ext=self.ZopeFind(self,obj_ids=["addFileForm.dtml"])
if ext:
return ext[0][1]('',globals(),version='1',AUTHENTICATED_USER=self.REQUEST.AUTHENTICATED_USER)
out=DTMLFile('dtml/newFileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version='1').__of__(self)
return out()
def addFile(self,vC,file,author,newName='',content_type='',RESPONSE=None):
""" add a new file"""
if newName=='':
filename=file.filename
id=filename[max(filename.rfind('/'),
filename.rfind('\\'),
filename.rfind(':'),
)+1:]
else:
id=newName
vC=self.REQUEST.form['vC']
manage_addVersionedFile(self,id,'','')
#if (getattr(self,'commentNonEmpty',0)==1) and vC.strip()=="":
ob=self._getOb(id)
ob.title=id
file2=file
obj=ob.manage_addVersionedFileObject(id,vC,author,file2,content_type=content_type)
self.REQUEST.SESSION['objID']=ob.getId()
self.REQUEST.SESSION['objID_parent']=None
if obj.getSize()==0:
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
return pt()
RESPONSE.redirect(self.REQUEST['URL1'])
def deleteEmptyObject(self,submit,RESPONSE=None):
"""deleteemptyobject"""
if submit=="delete it":
if self.REQUEST.SESSION['objID_parent']:
obj=getattr(self,self.REQUEST.SESSION['objID_parent'])
else:
obj=self
obj.manage_delObjects([self.REQUEST.SESSION['objID']])
RESPONSE.redirect(self.REQUEST['URL1'])
manage_addVersionedFileFolderForm=DTMLFile('dtml/folderAdd', globals())
def manage_addVersionedFileFolder(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=versionedFileFolder()
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)
class versionedFileObject(File):
"""File Object im Folder"""
meta_type = "versionedFileObject"
manage_editForm =DTMLFile('dtml/fileEdit',globals(),
Kind='File',kind='file')
manage_editForm._setName('manage_editForm')
def getVComment(self):
"""get the comment of this file"""
if not hasattr(self,'vComment') or (not self.vComment) or (self.vComment.lstrip()==""):
return "Add comment"
else:
return self.vComment
def manageVCommentForm(self):
"""add a comment"""
self.REQUEST.SESSION['refer']=self.REQUEST['HTTP_REFERER']
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addVComment')).__of__(self)
return pt()
def manageVComment(self,text,comment_author,submit,REQUEST=None):
"""manage comments"""
if submit =='change':
if text=='':
self.vComment=None
else:
self.vComment=text
self.vComment_author=comment_author
self.vComment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
if self.REQUEST.SESSION.has_key('refer'):
return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url()+"/history")
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 download(self):
"""download and lock"""
self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getId())
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
self.content_type="application/octet-stream"
#self.REQUEST.RESPONSE.redirect(self.absolute_url())
self.REQUEST.RESPONSE.write(self.index_html())
#self.REQUEST.RESPONSE.write("bl")
self.REQUEST.close()
def downloadLocked(self):
"""download and lock"""
if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
return "please login first"
if not self.aq_parent.lockedBy=="":
return "cannot be locked because is already locked by %s"%self.lockedBy
self.aq_parent.lockedBy=self.REQUEST['AUTHENTICATED_USER']
self.content_type="application/octet-stream"
self.REQUEST.RESPONSE.redirect(self.absolute_url())
def setVersionNumber(self,versionNumber):
"""set version"""
self.versionNumber=versionNumber
def getVersionNumber(self):
"""get version"""
return self.versionNumber
def lastEditor(self):
"""last Editor"""
if hasattr(self,'author'):
ret=self.author.replace("-","\n")
ret=ret.replace("\r","\n")
return ret
else:
jar=self._p_jar
oid=self._p_oid
if jar is None or oid is None: return None
return jar.db().history(oid)[0]['user_name']
manage_addVersionedFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject', version='1')
def manage_addVersionedFileObject(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, versionedFileObject(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 versionedFile(Folder):
"""Versioniertes File"""
def __init__(self, id, title, lockedBy,author):
"""init"""
self.id=id
self.title=title
self.lockedBy=lockedBy
self.author=author
def getComment(self):
"""get the comment of this file"""
if not hasattr(self,'comment') or (not self.comment) or (self.comment.lstrip()==""):
return "Add comment"
else:
return self.comment
meta_type="versionedFile"
def manageCommentForm(self):
"""add a comment"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addComment')).__of__(self)
return pt()
def manageComment(self,text,comment_author,submit,REQUEST=None):
"""manage comments"""
if submit =='change':
if text=='':
self.comment=None
else:
self.comment=text
self.comment_author=comment_author
self.comment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
def getLastVersion(self):
"""Last Version"""
tmp=0
lastVersion=None
for version in self.ZopeFind(self):
if hasattr(version[1],'versionNumber'):
if int(version[1].versionNumber) > tmp:
tmp=int(version[1].versionNumber,)
lastVersion=version[1]
return lastVersion
def index_html(self):
"""main view"""
lastVersion=self.getLastVersion()
#return "File:"+self.title+" Version:%i"%lastVersion.versionNumber," modified:",lastVersion.bobobase_modification_time()," size:",lastVersion.getSize(),"modified by:",lastVersion.lastEditor()
return "File: %s Version:%i modified:%s size:%s modified by:%s"%(self.title,lastVersion.versionNumber,lastVersion.getTime(),lastVersion.getSize(),lastVersion.lastEditor())
def getVersion(self):
tmp=0
for version in self.ZopeFind(self):
if hasattr(version[1],'versionNumber'):
if int(version[1].versionNumber) > tmp:
tmp=int(version[1].versionNumber,)
return tmp+1
security= ClassSecurityInfo()
security.declareProtected('AUTHENTICATED_USER','unlock')
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','versionHistory')).__of__(self)
return pt()
def getVersions(self):
"""get all versions"""
ret=[]
for version in self.ZopeFind(self):
if hasattr(version[1],'versionNumber'):
ret.append((version[1].versionNumber,version[1]))
ret.sort(sortv)
return ret
security.declareProtected('AUTHENTICATED_USER','forceunlock')
def forceunlock(self,RESPONSE):
"""unlock"""
self.lockedBy=''
security.declareProtected('AUTHENTICATED_USER','unlock')
def unlock(self,RESPONSE):
"""unlock"""
if str(self.lockedBy) in [str(self.REQUEST['AUTHENTICATED_USER'])]:
self.lockedBy=''
RESPONSE.redirect(self.REQUEST['URL2'])
else:
return "Sorry, not locked by you! (%s,%s)"%(self.lockedBy,self.REQUEST['AUTHENTICATED_USER'])
security.declareProtected('AUTHENTICATED_USER','addVersionedFileObjectForm')
def addVersionedFileObjectForm(self):
"""add a new version"""
if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
return "please login first"
if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
out=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version=self.getVersion()).__of__(self)
return out()
else:
return "Sorry file is locked by somebody else"
def manage_addVersionedFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
"""add"""
try: #der ganze vC unsinn muss ueberarbeitet werden
vC=self.REQUEST['vC']
except:
pass
author=self.REQUEST['author']
if changeName=="yes":
filename=file.filename
self.title=filename[max(filename.rfind('/'),
filename.rfind('\\'),
filename.rfind(':'),
)+1:]
if not newName=='':
self.title=newName[0:]
print self.title
id="V%i"%self.getVersion()+"_"+self.title
manage_addVersionedFileObject(self,id,vC,author,file,"V%i"%self.getVersion()+"_"+self.title,precondition, content_type)
objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
self.REQUEST.SESSION['objID_parent']=self.getId()
if RESPONSE:
obj=self.ZopeFind(self,obj_ids=[id])[0][1]
if obj.getSize()==0:
self.REQUEST.SESSION['objID']=obj.getId()
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
return pt()
else:
RESPONSE.redirect(self.REQUEST['URL2'])
else:
return self.ZopeFind(self,obj_ids=[id])[0][1]
security.declareProtected('AUTHENTICATED_USER','downloadLocked')
def download(self):
"""download and lock"""
self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
self.content_type="application/octet-stream"
#self.REQUEST.RESPONSE.write("bl")
self.REQUEST.RESPONSE.write(self.getLastVersion().index_html())
self.REQUEST.close()
#self.getLastVersion().content_type="application/octet-stream"
#self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
def downloadLocked(self):
"""download and lock"""
if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
return "please login first"
if not self.lockedBy=="":
return "cannot be locked because is already locked by %s"%self.lockedBy
self.lockedBy=self.REQUEST['AUTHENTICATED_USER']
self.getLastVersion().content_type="application/octet-stream"
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
def manage_addVersionedFileForm(self):
"""interface for adding the OSAS_root"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addVersionedFile.zpt')).__of__(self)
return pt()
def manage_addVersionedFile(self,id,title,lockedBy, author=None, RESPONSE=None):
"""add the OSAS_root"""
newObj=versionedFile(id,title,lockedBy,author)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
InitializeClass(versionedFile)
InitializeClass(versionedFileFolder)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>