"""actual version of the versioned file folder with external filestorage,
using the ExtFile Product, this version replaces externaVersionedFile.py
DW 11.10.2006
"""
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 difflib import Differ
from pprint import pprint
from Products.ExtFile.ExtFile import *
from Products.ZCatalog.CatalogPathAwareness import CatalogAware
try:
from Products.ImageArchive.ImageArchive import manage_AddImageZogiLib
except:
print "no images"
from threading import Thread
import shutil
import tempfile
import os.path
import urllib
import time
import logging
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/downloadVersionedFiles"
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()+".tgz"
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: getting the files</h3>"
for files in self.folder.ZopeFind(self.folder,obj_metatypes=['extVersionedFile']):
lastV=files[1].getContentObject()
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.getData())
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 you receive is a tar (gnutar) compressed file, after unpacking you will find a new folder <emph>tmp</emph> where the files are stored in.</p>"""
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 extVersionedFileFolder(Folder,ECHO_basis):
"""Folder with versioned files"""
meta_type = "extVersionedFileFolder"
security= ClassSecurityInfo()
security.declareProtected('AUTHENTICATED_USER','addFileForm')
file_meta_type=['extVersionedFile']
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 Image Index.html','action':'generateIndexHTML_image'},
{'label':'Generate history_template.html','action':'generateHistoryHTML'},
{'label':'Import Folder','action':'importFolderForm'},
{'label':'Export Folder','action':'exportFolder'},
{'label':'Position of version number','action':'changeHistoryFileNamesForm'},
)
def changeHistoryFileNamesForm(self):
"""change position of version num"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeHistoryFileNamesForm.zpt')).__of__(self)
return pt()
def changeHistoryFileNames(self,positionVersionNum="front",RESPONSE=None):
"""change position of version num"""
versions=self.ZopeFind(self,obj_metatypes=['extVersionedFileObject'],search_sub=1)
if not (getattr(self,'positionVersionNum','front')==positionVersionNum):
for version in versions:
if positionVersionNum=="front":
titleTmp=os.path.splitext(version[1].title)
titleTmp2="_".join(titleTmp[0].split("_")[0:-1])
if len(titleTmp)>1:
id=titleTmp[0].split("_")[-1]+"_"+titleTmp2+"."+titleTmp[1]
else:
id=titleTmp[0].split("_")[-1]+"_"+titleTmp2
else:
titleTmp="_".join(version[1].getId().split("_")[1:])
tmp=os.path.splitext(titleTmp)
if len(tmp)>1:
id=tmp[0]+"_"+version[1].getId().split("_")[0]+tmp[1]
else:
id=tmp[0]+"_"+version[1].getId().split("_")[0]
version[1].aq_parent.manage_renameObjects(ids=[version[1].getId()],new_ids=[id])
version[1].title=id
self.positionVersionNum=positionVersionNum
if RESPONSE:
RESPONSE.redirect("manage_main")
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):
"""import contents of a folder on the server"""
for fileName in os.listdir(path):
fn = os.path.join(path,fileName)
if os.path.isfile(fn):
f = file(fn)
self.addFile(vC=comment, file=f, author=author)
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
downloadZip=generateDownloadZip(self,self.absolute_url())
downloadZip()
return downloadZip.getResult()
## 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" """%"downloadFileFolder.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_image(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_image.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 generateAddFileForm(self,RESPONSE=None):
"""lege standard addfileform an"""
#TODO: write generateaddfileform only a dummy at them moment
if not self.ZopeFind(self,obj_ids=['addFileForm.dtml']):
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 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].getContentObject().getTime(),x[1].getContentObject().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].getContentObject().getVComment().lower()
except:
xc='ZZZZZZZZZZZZZ'.lower()
if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
try:
yc=y[1].getContentObject().getVComment().lower()
except:
yc='ZZZZZZZZZZZZZ'.lower()
return cmp(xc,yc)
def sortAuthor(x,y):
return cmp(x[1].getContentObject().lastEditor().lower(),y[1].getContentObject().lastEditor().lower())
versionedFiles=self.objectItems(self.file_meta_type)
logging.debug("versionedfiles: %s of type %s"%(repr(versionedFiles),repr(self.file_meta_type)))
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):
"""zusaetzlicher header"""
ext=self.ZopeFind(self,obj_ids=["header.html"])
if ext:
return ext[0][1]()
else:
return ""
security.declareProtected('View','index_html')
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']
# get new extVersionedFile
vf = self._newVersionedFile(id,title=id)
#if (getattr(self,'commentNonEmpty',0)==1) and vC.strip()=="":
# add file to this folder
self._setObject(id,vf)
file2=file
# add its content
logging.info("ADD: %s"%repr(vf))
obj=vf.addContentObject(id,vC,author=author,file=file2,content_type=content_type)
self.REQUEST.SESSION['objID']=vf.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 _newVersionedFile(self, id, title='', lockedBy=None, author=None):
"""factory for versioned files. to be overridden in derived classes."""
return extVersionedFile(id, title, lockedBy=lockedBy, author=author)
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'])
security.declareProtected('AUTHENTICATED_USER','fixVersionNumbers')
def fixVersionNumbers(self):
"""fix last version number of all files"""
for (id,vf) in self.getVersionedFiles():
vf.fixVersionNumbers()
manage_addextVersionedFileFolderForm=DTMLFile('dtml/extfolderAdd', globals())
def manage_addextVersionedFileFolder(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=extVersionedFileFolder()
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 extVersionedFileObject(ExtFile):
"""File Object im Folder"""
security= ClassSecurityInfo()
meta_type = "extVersionedFileObject"
manage_editForm=DTMLFile('dtml/fileEdit',globals(),
Kind='File',kind='file')
manage_editForm._setName('manage_editForm')
def __init__(self, id, title='', versionNumber=0, versionComment=None, time=None, author=None):
"""Initialize a new instance of extVersionedFileObject (taken from ExtFile)"""
ExtFile.__init__(self,id,title)
self.versionNumber = versionNumber
self.versionComment= versionComment
self.time = time
self.author = author
security.declarePublic('getTitle')
def getTitle(self):
"""get title"""
return self.title
def getData(self):
"""returns object content (calls ExtFile.index_html)"""
return ExtFile.index_html(self)
security.declarePublic('getVComment')
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")
security.declarePublic('getVersionComment')
def getVersionComment(self):
"""getversioncomment"""
return self.versionComment
security.declarePublic('getTime')
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,REQUEST=None,RESPONSE=None):
"""download and lock"""
self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getId())
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
#try:
# txt=self.index_html()
#except:
# txt=self.index_html(REQUEST,RESPONSE)
#
#self.REQUEST.RESPONSE.setHeader("Content-Length","str(len(txt)+1000)")
self.content_type="application/octet-stream"
self.REQUEST.RESPONSE.redirect(self.absolute_url())
#txt=urllib.urlopen(self.absolute_url()).read()
#self.REQUEST.RESPONSE.write(txt)
#self.REQUEST.close()
security.declareProtected('AUTHENTICATED_USER','downloadLocked')
def downloadLocked(self):
"""download and lock"""
if repr(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())
security.declarePublic('getVersionNumber')
def getVersionNumber(self):
"""get version"""
return self.versionNumber
security.declarePublic('getVersionComment')
def getVersionComment(self):
"""get version"""
return self.versionComment
security.declarePublic('lastEditor')
def lastEditor(self):
"""last Editor"""
if hasattr(self,'author'):
try:
ret=self.author.replace("-","\n")
except:#old version of versionded file sometimes stored the user object and not only the name the following corrects this
ret=str(self.author).replace("-","\n")
ret=ret.replace("\r","\n")
return ret.lstrip().rstrip()
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_addextVersionedFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='extVersionedFileObject',kind='extVersionedFileObject', version='1')
def manage_addextVersionedFileObject(self,id,vC='',author='', file='',title='',versionNumber=0,
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, extVersionedFileObject(id,title,versionNumber=versionNumber,versionComment=str(vC),author=author))
fob = self._getOb(id)
# 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:
fob.manage_upload(file)
if content_type:
fob.content_type=content_type
if REQUEST is not None:
REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
class extVersionedFile(CatalogAware,Folder):
"""Versioniertes File"""
meta_type = 'extVersionedFile'
# meta_type of contained objects
content_meta_type = ['extVersionedFileObject']
default_catalog = 'fileCatalog'
security=ClassSecurityInfo()
def __init__(self, id, title, lockedBy,author):
"""init"""
self.id=id
self.title=title
self.lockedBy=lockedBy
self.author=author
self.lastVersionNumber=0
self.lastVersionId=None
security.declarePublic('getTitle')
def getTitle(self):
"""get title"""
return self.title
def PrincipiaSearchSource(self):
"""Return cataloguable key for ourselves."""
return str(self)
def manageImagesForm(self):
"""manage Images attached to the file"""
self.REQUEST.SESSION['refer']=self.REQUEST['HTTP_REFERER']
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageImage')).__of__(self)
return pt()
def manageImages(self,imageUrl=None,caption=None,REQUEST=None):
"""manage URL"""
if imageUrl and (not imageUrl==""):
manage_AddImageZogiLib(self,libPath=imageUrl,caption=caption)
if self.REQUEST.SESSION.has_key('refer'):
return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
def changeImages(self,caption=None,submit=None,id=None,REQUEST=None):
"""manage URL"""
if submit=="change caption":
image=self.ZopeFind(self,obj_ids=[id])
if image:
image[0][1].caption=caption[0:]
elif submit=="delete":
image=self.ZopeFind(self,obj_ids=[id])
if image:
self.manage_delObjects([image[0][1].getId()])
if self.REQUEST.SESSION.has_key('refer'):
return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
def getImages(self):
"""get Images"""
images=self.ZopeFind(self,obj_metatypes=["ImageZogiLib"])
if not images:
return None
else:
return images
security.declarePublic('getComment')
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
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())
security.declarePublic('getLastChangeDate')
def getLastChangeDate(self):
"""get last change date"""
lv=self.getContentObject()
time=lv.getTime()
return time
def getLastEditor(self):
"""get last change date"""
lv=self.getContentObject()
le=lv.lastEditor()
return le
def getLockedBy(self):
"""get locked by"""
return str(self.lockedBy)
def getLastVersionNumber(self):
"""returns the highest version number of all included objects"""
lv = self.findLastVersion()
if lv:
return lv.getVersionNumber()
else:
return 0
def findLastVersion(self):
"""finds and returns the object with the highest version number"""
lvn=0
lv=None
for v in self.objectValues(self.content_meta_type):
logging.debug("findlastversion: check %s"%v.getId())
if v.getVersionNumber() > lvn:
lvn=v.getVersionNumber()
lv=v
if lv:
logging.debug("findlastversion: got %s"%lv.getId())
return lv
security.declarePublic('getLastVersion')
def getLastVersion(self):
"""Last Version (old)"""
tmp=0
lv=None
for v in self.objectValues(self.content_meta_type):
logging.debug("getlastversion: check %s"%v.getId())
if v.getVersionNumber() > tmp:
tmp=v.getVersionNumber()
lv=v
logging.debug("getlastversion: got %s"%lv.getId())
return lv
def getContentObject(self):
"""returns the last version object"""
if not self.lastVersionId:
lv = self.findLastVersion()
if lv is None:
return None
self.lastVersionNumber = lv.getVersionNumber()
self.lastVersionId = lv.getId()
return getattr(self, self.lastVersionId)
security.declarePublic('getData')
def getData(self):
"""Returns the content of the last version"""
ob = self.getContentObject()
if ob is not None:
return ob.getData()
else:
return None
def diff(self,data):
"""differenz between lastversion and data"""
d=Differ()
tmp=self.getData()
#print "XX",data,tmp
try:
l=list(d.compare(data.splitlines(1),tmp.splitlines(1)))
except:
return 0,""
plus=0
minus=0
for a in l:
if a[0]=='+':
plus+=1
if a[0]=='-':
minus+=1
return max([plus,minus]),l
security.declarePublic('index_html')
def index_html(self):
"""main view"""
#lastVersion=self.getContentObject()
#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())
return self.history()
security.declarePublic('getVersion')
def getVersion(self):
# TODO: this is ugly and it returns the next version number
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
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=None):
"""unlock"""
#safe who had the lock
if self.lockedBy:
self.brokenLock=str(self.lockedBy)
else:
self.brokenLock=""
self.lockedBy=''
return self.brokenLock
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['HTTP_REFERER'])
else:
return "Sorry, not locked by you! (%s,%s)"%(self.lockedBy,self.REQUEST['AUTHENTICATED_USER'])
def _newContentObject(self, id, title='', versionNumber=0, versionComment=None, time=None, author=None):
"""factory for content objects. to be overridden in derived classes."""
return extVersionedFileObject(id,title,versionNumber=versionNumber,versionComment=versionComment,time=time,author=author)
def addContentObject(self,id,vC,author=None,file=None,title='',changeName='no',newName='',from_tmp=False,
precondition='', content_type=''):
"""add"""
if changeName=="yes":
filename=file.filename
self.title=filename[max(filename.rfind('/'),
filename.rfind('\\'),
filename.rfind(':'),
)+1:]
if not newName=='':
self.title=newName[0:]
posVersNum=getattr(self,'positionVersionNum','front')
versNum = self.getLastVersionNumber() + 1
if posVersNum=='front':
id="V%i_%s"%(versNum,self.title)
else:
fn=os.path.splitext(self.title)
if len(fn)>1:
id=fn[0]+"_V%i%s"%(versNum,fn[1])
else:
id=fn[0]+"_V%i"%versNum
# what does this do?
id, title = cookId(id, title, file)
self=self.this()
# First, we create the file without data:
self._setObject(id, self._newContentObject(id,title,versionNumber=versNum,versionComment=str(vC),
time=time.localtime(),author=author))
fob = self._getOb(id)
# 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 and not from_tmp:
fob.manage_upload(file)
elif file and from_tmp:
fob.manage_file_upload(file) # manage_upload_from_tmp doesn't exist in ExtFile2
# fob.manage_upload_from_tmp(file) # manage_upload_from_tmp doesn't exist in ExtFile2
fob.content_type=content_type
self.lastVersionNumber = versNum
self.lastVersionId = id
logging.debug("addcontentobject: lastversion=%s"%self.getData())
logging.debug("reindex1: %s in %s"%(repr(self),repr(self.default_catalog)))
self.reindex_object()
logging.debug("addcontentobject: fob_data=%s"%fob.getData())
return fob
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==''):
ext=self.ZopeFind(self.aq_parent,obj_ids=["addNewVersion.dtml"])
if ext:
return ext[0][1]('',globals(),version=self.getVersion(),lastComment=self.getContentObject().getVersionComment(),AUTHENTICATED_USER=self.REQUEST.AUTHENTICATED_USER)
else:
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='', from_tmp=False, RESPONSE=None):
"""add"""
try: #der ganze vC unsinn muss ueberarbeitet werden
vC=self.REQUEST['vC']
except:
pass
author=self.REQUEST['author']
ob = self.addContentObject(id, vC, author, file, title, changeName=changeName, newName=newName, from_tmp=from_tmp,
precondition=precondition, content_type=content_type)
self.REQUEST.SESSION['objID_parent']=self.getId()
if RESPONSE:
if ob.getSize()==0:
self.REQUEST.SESSION['objID']=ob.getId()
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
return pt()
else:
RESPONSE.redirect(self.REQUEST['URL2'])
else:
return ob
def download(self):
"""download and lock"""
self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getContentObject().getId())
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
self.content_type="application/octet-stream"
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getContentObject().getId())
security.declareProtected('AUTHENTICATED_USER','downloadLocked')
def downloadLocked(self):
"""download and lock"""
if repr(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.getContentObject().content_type="application/octet-stream"
self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getContentObject().getId())
security.declareProtected('AUTHENTICATED_USER','fixVersionNumbers')
def fixVersionNumbers(self):
"""check last version number and id"""
if not hasattr(self, 'lastVersionId'):
self.lastVersionNumber = 0
self.lastVersionId = None
lv = self.getContentObject()
if lv is not None:
lvn = lv.getVersionNumber()
if lvn == 0:
lvn = 1
lv.versionNumber = 1
self.lastVersionNumber = lvn
self.lastVersionId = lv.getId()
else:
self.lastVersionNumber = 0
self.lastVersionId = None
logging.debug("fixing last version number of %s to %s (%s)"%(self.getId(),self.lastVersionNumber,self.lastVersionId))
def manage_addextVersionedFileForm(self):
"""interface for adding the OSAS_root"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addextVersionedFile.zpt')).__of__(self)
return pt()
def manage_addextVersionedFile(self,id,title,lockedBy, author=None, RESPONSE=None):
"""add the OSAS_root"""
newObj=extVersionedFile(id,title,lockedBy,author)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
InitializeClass(extVersionedFile)
InitializeClass(extVersionedFileFolder)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to extVersionedFile.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / versionedFile