1: """actual version of the versioned file folder with external filestorage,
2: using the ExtFile Product, this version replaces externaVersionedFile.py
3: DW 11.10.2006
4: """
5:
6: from OFS.Folder import Folder
7: from OFS.Image import File
8: from OFS.Image import cookId
9: from Globals import DTMLFile, InitializeClass,package_home
10: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
11: from AccessControl import getSecurityManager
12: from Products.PageTemplates.PageTemplate import PageTemplate
13: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
14: from AccessControl import ClassSecurityInfo
15: from difflib import Differ
16: from pprint import pprint
17: from Products.ExtFile.ExtFile import *
18: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
19:
20: try:
21: from Products.ImageArchive.ImageArchive import manage_AddImageZogiLib
22: except:
23: print "no images"
24:
25: from threading import Thread
26: import shutil
27: import tempfile
28: import os.path
29: import urllib
30: import time
31: import logging
32:
33: try:
34: from Products.ECHO_content.ECHO_collection import ECHO_basis
35: except:
36: print "ECHO Elements not imported"
37: class ECHO_basis:
38: """leer"""
39: manage_options=()
40:
41:
42: def sortv(x,y):
43: return cmp(x[0],y[0])
44: tdir = "/tmp/downloadVersionedFiles"
45:
46: class generateDownloadZip:
47: """generateDownloadSet"""
48:
49: def __init__(self,folderObject,url):
50: """init downloadzip"""
51: self.folder=folderObject
52: self.done=None
53: self.response=""
54: self.url=url
55:
56: def __call__(self):
57: """call generate download zip"""
58: storeTempDir=tempfile.tempdir
59: tempfile.tempdir=tdir
60:
61: tmpPath=tempfile.mktemp()
62: tmpZip=tempfile.mktemp()+".tgz"
63: tmpFn=os.path.split(tmpZip)[1]
64:
65: if not os.path.exists(tempfile.tempdir):
66: os.mkdir(tempfile.tempdir)
67:
68: if not os.path.exists(tmpPath):
69: os.mkdir(tmpPath)
70:
71: self.response="<h3>1. step: getting the files</h3>"
72:
73: for files in self.folder.ZopeFind(self.folder,obj_metatypes=['extVersionedFile']):
74: lastV=files[1].getLastVersion()
75: self.response+=str("<p>Get File: %s<br>\n"%lastV.title)
76:
77: savePath=os.path.join(tmpPath,lastV.title)
78: fh=file(savePath,"w")
79: fh.write(lastV.getData())
80: fh.close()
81:
82: self.response+="<h3>2. step: creating the downloadable file</h3>"
83: self.response+="<p>Create gtar<br>"
84: self.response+="<p>This can take a while....<br>\n"
85:
86: fh=os.popen2("tar zcvf %s %s/*"%(tmpZip,tmpPath),1)[1]
87: self.response+="<br>"
88: for c in fh.read():
89: self.response+=c
90: if c==")":
91: self.response+="<br>\n"
92:
93: shutil.rmtree(tmpPath)
94:
95: self.response+="<p>finished<br>\n"
96:
97: len=os.stat(tmpZip)[6]
98: downloadUrl=self.url+"/downloadSet"
99: self.response+="""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len)
100: 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>"""
101: self.response+="""<p>The file will be stored for a while, you can download it later, the URL is:</p>
102: <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn)
103:
104: self.done=True
105:
106:
107: def getResult(self):
108: """get result"""
109: return self.response
110:
111: def isDone(self):
112: if self.done:
113: return True
114: else:
115: return False
116:
117:
118: class extVersionedFileFolder(Folder,ECHO_basis):
119: """Folder with versioned files"""
120: meta_type = "extVersionedFileFolder"
121:
122: security= ClassSecurityInfo()
123: security.declareProtected('AUTHENTICATED_USER','addFileForm')
124:
125: filesMetaType=['extVersionedFile']
126:
127: if ECHO_basis:
128: optTMP= Folder.manage_options+ECHO_basis.manage_options
129: else:
130: optTMP= Folder.manage_options
131:
132: manage_options =optTMP+(
133: {'label':'Generate Index.html','action':'generateIndexHTML'},
134: {'label':'Generate Image Index.html','action':'generateIndexHTML_image'},
135: {'label':'Generate history_template.html','action':'generateHistoryHTML'},
136: {'label':'Import Folder','action':'importFolderForm'},
137: {'label':'Export Folder','action':'exportFolder'},
138: {'label':'Position of version number','action':'changeHistoryFileNamesForm'},
139: )
140:
141:
142: def changeHistoryFileNamesForm(self):
143: """change position of version num"""
144: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeHistoryFileNamesForm.zpt')).__of__(self)
145: return pt()
146:
147:
148: def changeHistoryFileNames(self,positionVersionNum="front",RESPONSE=None):
149: """change position of version num"""
150: versions=self.ZopeFind(self,obj_metatypes=['extVersionedFileObject'],search_sub=1)
151:
152: if not (getattr(self,'positionVersionNum','front')==positionVersionNum):
153:
154: for version in versions:
155:
156: if positionVersionNum=="front":
157:
158: titleTmp=os.path.splitext(version[1].title)
159: titleTmp2="_".join(titleTmp[0].split("_")[0:-1])
160: if len(titleTmp)>1:
161: id=titleTmp[0].split("_")[-1]+"_"+titleTmp2+"."+titleTmp[1]
162: else:
163: id=titleTmp[0].split("_")[-1]+"_"+titleTmp2
164:
165: else:
166: titleTmp="_".join(version[1].getId().split("_")[1:])
167: tmp=os.path.splitext(titleTmp)
168: if len(tmp)>1:
169: id=tmp[0]+"_"+version[1].getId().split("_")[0]+tmp[1]
170: else:
171: id=tmp[0]+"_"+version[1].getId().split("_")[0]
172:
173: version[1].aq_parent.manage_renameObjects(ids=[version[1].getId()],new_ids=[id])
174: version[1].title=id
175:
176: self.positionVersionNum=positionVersionNum
177: if RESPONSE:
178: RESPONSE.redirect("manage_main")
179:
180:
181:
182: def importFolderForm(self):
183: """form fuer folder import"""
184: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importFolderForm.zpt')).__of__(self)
185: return pt()
186:
187: def importFolder(self,path,comment="",author=None,lockedBy=None,RESPONSE=None):
188: """importiere inhalt eines folders"""
189:
190: for fileName in os.listdir(path):
191: if os.path.isfile(os.path.join(path,fileName)):
192: manage_addextVersionedFile(self,fileName,'','')
193: id=fileName
194: ob=self._getOb(fileName)
195: ob.title=id
196: file2=file(os.path.join(path,fileName))
197:
198: obj=ob.manage_addextVersionedFileObject(id,comment,author,file2,content_type='')
199:
200: if RESPONSE:
201: RESPONSE.redirect(self.REQUEST['URL1'])
202:
203: zipThreads={}
204: zipThreads2={}
205:
206: def refreshTxt(self):
207: """txt fuer refresh"""
208: tn=self.REQUEST.SESSION['threadName']
209: return """ 2;url=%s?repeat=%s """%(self.absolute_url()+"/exportFolder",tn)
210:
211: def exportFolder(self,repeat=None):
212: """exportiert alle akutellen files des folders"""
213: threadName=repeat
214:
215: downloadZip=generateDownloadZip(self,self.absolute_url())
216: downloadZip()
217: return downloadZip.getResult()
218: ## if not threadName or threadName=="":
219: ## threadStart=generateDownloadZip(self,self.absolute_url())
220: ## thread=Thread(target=threadStart)
221:
222: ## thread.start()
223:
224:
225: ## self.zipThreads[thread.getName()[0:]]=threadStart
226: ## self.zipThreads2[thread.getName()[0:]]=thread
227: ## self.REQUEST.SESSION['threadName']=thread.getName()[0:]
228: ## wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
229: ## if wait_template:
230: ## return wait_template[0][1]()
231: ## pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
232: ## return pt()
233:
234: ## else:
235: ## self.REQUEST.SESSION['threadName']=threadName
236:
237: ## if (self.zipThreads[threadName].getResult()==None):
238:
239: ## wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
240: ## if wait_template:
241: ## return wait_template[0][1]()
242:
243: ## pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
244: ## return pt()
245: ## else:
246: ## if self.zipThreads[threadName].isDone():
247: ## self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
248: ## self.zipThreads2[threadName].join()
249: ## del(self.zipThreads2[threadName])
250: ## del(self.zipThreads[threadName])
251: ## pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
252: ## return pt()
253:
254: ## else:
255: ## self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
256: ## self.REQUEST.SESSION['threadName']=threadName
257: ## pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)
258: ## return pt()
259:
260: def downloadSet(self,fn):
261: """download prepared set"""
262: filename=os.path.join(tdir,fn)
263:
264:
265: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"downloadFileFolder.tgz")
266: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
267: len=os.stat(filename)[6]
268: self.REQUEST.RESPONSE.setHeader("Content-Length",len)
269: images=file(filename).read()
270: self.REQUEST.RESPONSE.write(images)
271: self.REQUEST.RESPONSE.close()
272:
273:
274:
275: def helpDownload(self):
276: """download help"""
277:
278: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','helpDownload')).__of__(self)
279: return pt()
280:
281: def generateIndexHTML_image(self,RESPONSE=None):
282: """lege standard index.html an"""
283:
284:
285: if not self.ZopeFind(self,obj_ids=['index.html']):
286: zt=ZopePageTemplate('index.html')
287: self._setObject('index.html',zt)
288: default_content_fn = os.path.join(package_home(globals()),
289: 'zpt/versionFileFolderMain_image.zpt')
290: text = open(default_content_fn).read()
291: zt.pt_edit(text, 'text/html')
292:
293: else:
294: return "already exists!"
295:
296: if RESPONSE is not None:
297: RESPONSE.redirect('manage_main')
298:
299:
300: def generateAddFileForm(self,RESPONSE=None):
301: """lege standard addfileform an"""
302: #TODO: write generateaddfileform only a dummy at them moment
303:
304: if not self.ZopeFind(self,obj_ids=['addFileForm.dtml']):
305: zt=ZopePageTemplate('index.html')
306: self._setObject('index.html',zt)
307: default_content_fn = os.path.join(package_home(globals()),
308: 'zpt/versionFileFolderMain.zpt')
309: text = open(default_content_fn).read()
310: zt.pt_edit(text, 'text/html')
311:
312: else:
313: return "already exists!"
314:
315: if RESPONSE is not None:
316: RESPONSE.redirect('manage_main')
317:
318:
319: def generateIndexHTML(self,RESPONSE=None):
320: """lege standard index.html an"""
321: if not self.ZopeFind(self,obj_ids=['index.html']):
322: zt=ZopePageTemplate('index.html')
323: self._setObject('index.html',zt)
324: default_content_fn = os.path.join(package_home(globals()),
325: 'zpt/versionFileFolderMain.zpt')
326: text = open(default_content_fn).read()
327: zt.pt_edit(text, 'text/html')
328:
329: else:
330: return "already exists!"
331:
332: if RESPONSE is not None:
333: RESPONSE.redirect('manage_main')
334:
335:
336: def generateHistoryHTML(self,RESPONSE=None):
337: """lege standard index.html an"""
338: if not self.ZopeFind(self,obj_ids=['history_template.html']):
339: zt=ZopePageTemplate('history_template.html')
340: self._setObject('history_template.html',zt)
341: default_content_fn = os.path.join(package_home(globals()),
342: 'zpt/versionHistory.zpt')
343: text = open(default_content_fn).read()
344: zt.pt_edit(text, 'text/html')
345:
346: else:
347: return "already exists!"
348:
349: if RESPONSE is not None:
350: RESPONSE.redirect('manage_main')
351:
352:
353: def getVersionedFiles(self,sortField='title'):
354: """get all versioned files"""
355:
356: def sortName(x,y):
357: return cmp(x[1].title.lower(),y[1].title.lower())
358:
359: def sortDate(x,y):
360: return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
361:
362: def sortComment(x,y):
363: try:
364: xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
365: except:
366: xc='ZZZZZZZZZZZZZ'.lower()
367:
368: try:
369: yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
370: except:
371: yc='ZZZZZZZZZZZZZ'.lower()
372:
373: if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
374: try:
375: xc=x[1].getLastVersion().getVComment().lower()
376: except:
377: xc='ZZZZZZZZZZZZZ'.lower()
378:
379: if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
380: try:
381: yc=y[1].getLastVersion().getVComment().lower()
382: except:
383: yc='ZZZZZZZZZZZZZ'.lower()
384:
385: return cmp(xc,yc)
386:
387: def sortAuthor(x,y):
388:
389: return cmp(x[1].getLastVersion().lastEditor().lower(),y[1].getLastVersion().lastEditor().lower())
390:
391: versionedFiles=self.ZopeFind(self,obj_metatypes=self.filesMetaType)
392:
393: if sortField=='title':
394: versionedFiles.sort(sortName)
395: elif sortField=='date':
396: versionedFiles.sort(sortDate)
397: elif sortField=='author':
398: versionedFiles.sort(sortAuthor)
399: elif sortField=='comment':
400: versionedFiles.sort(sortComment)
401:
402: return versionedFiles
403:
404:
405: def header_html(self):
406: """zusaetzlicher header"""
407: ext=self.ZopeFind(self,obj_ids=["header.html"])
408: if ext:
409: return ext[0][1]()
410: else:
411: return ""
412:
413:
414: security.declareProtected('View','index_html')
415: def index_html(self):
416: """main"""
417: ext=self.ZopeFind(self,obj_ids=["index.html"])
418: if ext:
419: return ext[0][1]()
420:
421: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionFileFolderMain')).__of__(self)
422: return pt()
423:
424:
425:
426: def addFileForm(self):
427: """add a file"""
428: ext=self.ZopeFind(self,obj_ids=["addFileForm.dtml"])
429: if ext:
430: return ext[0][1]('',globals(),version='1',AUTHENTICATED_USER=self.REQUEST.AUTHENTICATED_USER)
431:
432: out=DTMLFile('dtml/newFileAdd', globals(),Kind='versionedFileObject',kind='versionedFileObject',version='1').__of__(self)
433: return out()
434:
435:
436: def addFile(self,vC,file,author,newName='',content_type='',RESPONSE=None):
437: """ add a new file"""
438: if newName=='':
439: filename=file.filename
440: id=filename[max(filename.rfind('/'),
441: filename.rfind('\\'),
442: filename.rfind(':'),
443: )+1:]
444:
445: else:
446: id=newName
447:
448: vC=self.REQUEST.form['vC']
449: manage_addextVersionedFile(self,id,'','')
450: #if (getattr(self,'commentNonEmpty',0)==1) and vC.strip()=="":
451:
452:
453: ob=self._getOb(id)
454: ob.title=id
455: file2=file
456:
457: logging.info("ADD: %s"%repr(ob))
458: obj=ob.manage_addVersionedFileObject(id,vC,author,file2,content_type=content_type)
459: self.REQUEST.SESSION['objID']=ob.getId()
460: self.REQUEST.SESSION['objID_parent']=None
461:
462: if obj.getSize()==0:
463: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
464: return pt()
465:
466: RESPONSE.redirect(self.REQUEST['URL1'])
467:
468:
469: def deleteEmptyObject(self,submit,RESPONSE=None):
470: """deleteemptyobject"""
471: if submit=="delete it":
472: if self.REQUEST.SESSION['objID_parent']:
473: obj=getattr(self,self.REQUEST.SESSION['objID_parent'])
474:
475: else:
476: obj=self
477: obj.manage_delObjects([self.REQUEST.SESSION['objID']])
478:
479: RESPONSE.redirect(self.REQUEST['URL1'])
480:
481:
482: manage_addextVersionedFileFolderForm=DTMLFile('dtml/extfolderAdd', globals())
483:
484:
485: def manage_addextVersionedFileFolder(self, id, title='',
486: createPublic=0,
487: createUserF=0,
488: REQUEST=None):
489: """Add a new Folder object with id *id*.
490:
491: If the 'createPublic' and 'createUserF' parameters are set to any true
492: value, an 'index_html' and a 'UserFolder' objects are created respectively
493: in the new folder.
494: """
495: ob=extVersionedFileFolder()
496: ob.id=str(id)
497: ob.title=title
498: self._setObject(id, ob)
499: ob=self._getOb(id)
500:
501: checkPermission=getSecurityManager().checkPermission
502:
503: if createUserF:
504: if not checkPermission('Add User Folders', ob):
505: raise Unauthorized, (
506: 'You are not authorized to add User Folders.'
507: )
508: ob.manage_addUserFolder()
509:
510:
511: if REQUEST is not None:
512: return self.manage_main(self, REQUEST, update_menu=1)
513:
514:
515:
516: class extVersionedFileObject(ExtFile):
517: """File Object im Folder"""
518: security= ClassSecurityInfo()
519: meta_type = "extVersionedFileObject"
520:
521: manage_editForm =DTMLFile('dtml/fileEdit',globals(),
522: Kind='File',kind='file')
523: manage_editForm._setName('manage_editForm')
524:
525: security.declarePublic('getTitle')
526: def getTitle(self):
527: """get title"""
528: return self.title
529:
530: def getData(self):
531: """returns object content (calls ExtFile.index_html)"""
532: return ExtFile.index_html(self)
533:
534: security.declarePublic('getVComment')
535: def getVComment(self):
536: """get the comment of this file"""
537: if not hasattr(self,'vComment') or (not self.vComment) or (self.vComment.lstrip()==""):
538: return "Add comment"
539:
540: else:
541: return self.vComment
542:
543: def manageVCommentForm(self):
544: """add a comment"""
545:
546: self.REQUEST.SESSION['refer']=self.REQUEST['HTTP_REFERER']
547: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addVComment')).__of__(self)
548: return pt()
549:
550: def manageVComment(self,text,comment_author,submit,REQUEST=None):
551: """manage comments"""
552: if submit =='change':
553: if text=='':
554: self.vComment=None
555: else:
556: self.vComment=text
557: self.vComment_author=comment_author
558:
559: self.vComment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
560:
561: if self.REQUEST.SESSION.has_key('refer'):
562:
563: return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
564: return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url()+"/history")
565:
566:
567: security.declarePublic('getVersionComment')
568: def getVersionComment(self):
569: """getversioncomment"""
570: return self.versionComment
571:
572: security.declarePublic('getTime')
573:
574: def getTime(self):
575: """getTime"""
576: #return self.bobobase_modification_time().ISO()
577: if hasattr(self,'time'):
578: return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
579: elif hasattr(self,'timefixed'):
580: return self.timefixed
581: else:
582: setattr(self,'timefixed',self.bobobase_modification_time().ISO())
583: return self.bobobase_modification_time().ISO()
584:
585:
586:
587:
588:
589: def download(self,REQUEST=None,RESPONSE=None):
590: """download and lock"""
591:
592: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getId())
593: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
594: #try:
595: # txt=self.index_html()
596: #except:
597: # txt=self.index_html(REQUEST,RESPONSE)
598: #
599: #self.REQUEST.RESPONSE.setHeader("Content-Length","str(len(txt)+1000)")
600:
601: self.content_type="application/octet-stream"
602: self.REQUEST.RESPONSE.redirect(self.absolute_url())
603: #txt=urllib.urlopen(self.absolute_url()).read()
604: #self.REQUEST.RESPONSE.write(txt)
605:
606:
607: #self.REQUEST.close()
608:
609: security.declareProtected('AUTHENTICATED_USER','downloadLocked')
610: def downloadLocked(self):
611: """download and lock"""
612:
613:
614: if repr(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
615: return "please login first"
616: if not self.aq_parent.lockedBy=="":
617: return "cannot be locked because is already locked by %s"%self.lockedBy
618: self.aq_parent.lockedBy=self.REQUEST['AUTHENTICATED_USER']
619:
620: self.content_type="application/octet-stream"
621: self.REQUEST.RESPONSE.redirect(self.absolute_url())
622:
623: def setVersionNumber(self,versionNumber):
624: """set version"""
625: self.versionNumber=versionNumber
626:
627:
628: security.declarePublic('getVersionNumber')
629: def getVersionNumber(self):
630: """get version"""
631: return self.versionNumber
632:
633: security.declarePublic('getVersionComment')
634: def getVersionComment(self):
635: """get version"""
636: return self.versionComment
637:
638:
639:
640: security.declarePublic('lastEditor')
641: def lastEditor(self):
642: """last Editor"""
643: if hasattr(self,'author'):
644: try:
645: ret=self.author.replace("-","\n")
646: except:#old version of versionded file sometimes stored the user object and not only the name the following corrects this
647: ret=str(self.author).replace("-","\n")
648: ret=ret.replace("\r","\n")
649: return ret.lstrip().rstrip()
650:
651: else:
652: jar=self._p_jar
653: oid=self._p_oid
654:
655: if jar is None or oid is None: return None
656:
657: return jar.db().history(oid)[0]['user_name']
658:
659:
660: manage_addextVersionedFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='extVersionedFileObject',kind='extVersionedFileObject', version='1')
661:
662: def manage_addextVersionedFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
663: REQUEST=None):
664: """Add a new File object.
665:
666: Creates a new File object 'id' with the contents of 'file'"""
667:
668: id=str(id)
669: title=str(title)
670: content_type=str(content_type)
671: precondition=str(precondition)
672:
673: id, title = cookId(id, title, file)
674:
675: self=self.this()
676:
677: # First, we create the file without data:
678: self._setObject(id, extVersionedFileObject(id,title,'',content_type, precondition))
679: self._getOb(id).versionComment=str(vC)
680: self._getOb(id).time=time.localtime()
681:
682: setattr(self._getOb(id),'author',author)
683:
684: # Now we "upload" the data. By doing this in two steps, we
685: # can use a database trick to make the upload more efficient.
686: if file:
687: self._getOb(id).manage_upload(file)
688: if content_type:
689: self._getOb(id).content_type=content_type
690:
691: if REQUEST is not None:
692: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
693:
694:
695:
696:
697: class extVersionedFile(CatalogAware,Folder):
698: """Versioniertes File"""
699:
700: default_catalog='fileCatalog'
701:
702: security= ClassSecurityInfo()
703:
704: security.declarePublic('getTitle')
705: def getTitle(self):
706: """get title"""
707: return self.title
708:
709: def PrincipiaSearchSource(self):
710: """Return cataloguable key for ourselves."""
711: return str(self)
712:
713: def __init__(self, id, title, lockedBy,author):
714: """init"""
715: self.id=id
716: self.title=title
717: self.lockedBy=lockedBy
718: self.author=author
719:
720: def manageImagesForm(self):
721: """manage Images attached to the file"""
722:
723: self.REQUEST.SESSION['refer']=self.REQUEST['HTTP_REFERER']
724:
725: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageImage')).__of__(self)
726: return pt()
727:
728: def manageImages(self,imageUrl=None,caption=None,REQUEST=None):
729: """manage URL"""
730: if imageUrl and (not imageUrl==""):
731: manage_AddImageZogiLib(self,libPath=imageUrl,caption=caption)
732:
733: if self.REQUEST.SESSION.has_key('refer'):
734:
735: return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
736: return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
737:
738:
739:
740: def changeImages(self,caption=None,submit=None,id=None,REQUEST=None):
741: """manage URL"""
742: if submit=="change caption":
743: image=self.ZopeFind(self,obj_ids=[id])
744: if image:
745: image[0][1].caption=caption[0:]
746:
747: elif submit=="delete":
748: image=self.ZopeFind(self,obj_ids=[id])
749: if image:
750: self.manage_delObjects([image[0][1].getId()])
751:
752:
753: if self.REQUEST.SESSION.has_key('refer'):
754:
755: return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
756: return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
757:
758:
759:
760:
761: def getImages(self):
762: """get Images"""
763: images=self.ZopeFind(self,obj_metatypes=["ImageZogiLib"])
764: if not images:
765: return None
766: else:
767: return images
768:
769: security.declarePublic('getComment')
770: def getComment(self):
771: """get the comment of this file"""
772: if not hasattr(self,'comment') or (not self.comment) or (self.comment.lstrip()==""):
773: return "Add comment"
774:
775: else:
776: return self.comment
777:
778:
779: meta_type="extVersionedFile"
780:
781: def manageCommentForm(self):
782: """add a comment"""
783: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addComment')).__of__(self)
784: return pt()
785:
786: def manageComment(self,text,comment_author,submit,REQUEST=None):
787: """manage comments"""
788: if submit =='change':
789: if text=='':
790: self.comment=None
791: else:
792: self.comment=text
793: self.comment_author=comment_author
794:
795: self.comment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
796:
797: return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
798:
799: security.declarePublic('getLastChangeDate')
800:
801: def getLastChangeDate(self):
802: """get last change date"""
803: lv=self.getLastVersion()
804: time=lv.getTime()
805: return time
806:
807: def getLastEditor(self):
808: """get last change date"""
809: lv=self.getLastVersion()
810: le=lv.lastEditor()
811: return le
812:
813: def getLockedBy(self):
814: """get locked by"""
815: return str(self.lockedBy)
816:
817: security.declarePublic('getLastVersion')
818: def getLastVersion(self):
819: """Last Version"""
820: tmp=0
821: lastVersion=None
822:
823: for version in self.ZopeFind(self):
824:
825: if hasattr(version[1],'versionNumber'):
826:
827: if int(version[1].versionNumber) > tmp:
828: tmp=int(version[1].versionNumber,)
829: lastVersion=version[1]
830: if lastVersion==None:
831: lastVersion=version[1]
832: lastVersion.versionNumber=1
833: return lastVersion
834:
835:
836: def diff(self,data):
837: """differenz between lastversion and data"""
838: d=Differ()
839: tmp=self.getLastVersion().getData()
840: #print "XX",data,tmp
841: try:
842: l=list(d.compare(data.splitlines(1),tmp.splitlines(1)))
843: except:
844: return 0,""
845: plus=0
846: minus=0
847: for a in l:
848: if a[0]=='+':
849: plus+=1
850: if a[0]=='-':
851: minus+=1
852:
853: return max([plus,minus]),l
854:
855:
856: security.declarePublic('index_html')
857: def index_html(self):
858: """main view"""
859: #lastVersion=self.getLastVersion()
860: #return "File:"+self.title+" Version:%i"%lastVersion.versionNumber," modified:",lastVersion.bobobase_modification_time()," size:",lastVersion.getSize(),"modified by:",lastVersion.lastEditor()
861: #return "File: %s Version:%i modified:%s size:%s modified by:%s"%(self.title,lastVersion.versionNumber,lastVersion.getTime(),lastVersion.getSize(),lastVersion.lastEditor())
862: return self.history()
863:
864:
865: security.declarePublic('getVersion')
866: def getVersion(self):
867: tmp=0
868: for version in self.ZopeFind(self):
869:
870: if hasattr(version[1],'versionNumber'):
871:
872: if int(version[1].versionNumber) > tmp:
873: tmp=int(version[1].versionNumber,)
874: return tmp+1
875:
876:
877: def history(self):
878: """history"""
879:
880: ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
881: if ext:
882: return getattr(self,ext[0][1].getId())()
883:
884: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
885: return pt()
886:
887: def getVersions(self):
888: """get all versions"""
889: ret=[]
890: for version in self.ZopeFind(self):
891: if hasattr(version[1],'versionNumber'):
892: ret.append((version[1].versionNumber,version[1]))
893: ret.sort(sortv)
894: return ret
895:
896: security.declareProtected('AUTHENTICATED_USER','forceunlock')
897: def forceunlock(self,RESPONSE=None):
898: """unlock"""
899: #safe who had the lock
900: if self.lockedBy:
901: self.brokenLock=str(self.lockedBy)
902: else:
903: self.brokenLock=""
904: self.lockedBy=''
905: return self.brokenLock
906:
907: security.declareProtected('AUTHENTICATED_USER','unlock')
908: def unlock(self,RESPONSE):
909: """unlock"""
910: if str(self.lockedBy) in [str(self.REQUEST['AUTHENTICATED_USER'])]:
911: self.lockedBy=''
912: RESPONSE.redirect(self.REQUEST['HTTP_REFERER'])
913: else:
914: return "Sorry, not locked by you! (%s,%s)"%(self.lockedBy,self.REQUEST['AUTHENTICATED_USER'])
915:
916:
917:
918: security.declareProtected('AUTHENTICATED_USER','addVersionedFileObjectForm')
919: def addVersionedFileObjectForm(self):
920: """add a new version"""
921:
922: if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
923: return "please login first"
924: if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
925: ext=self.ZopeFind(self.aq_parent,obj_ids=["addNewVersion.dtml"])
926: if ext:
927: return ext[0][1]('',globals(),version=self.getVersion(),lastComment=self.getLastVersion().getVersionComment(),AUTHENTICATED_USER=self.REQUEST.AUTHENTICATED_USER)
928: else:
929: out=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version=self.getVersion()).__of__(self)
930: return out()
931: else:
932: return "Sorry file is locked by somebody else"
933:
934: def manage_addVersionedFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
935: """add"""
936: try: #der ganze vC unsinn muss ueberarbeitet werden
937: vC=self.REQUEST['vC']
938: except:
939: pass
940:
941: author=self.REQUEST['author']
942:
943: if changeName=="yes":
944: filename=file.filename
945: self.title=filename[max(filename.rfind('/'),
946: filename.rfind('\\'),
947: filename.rfind(':'),
948: )+1:]
949:
950: if not newName=='':
951: self.title=newName[0:]
952:
953: positionVersionNum=getattr(self,'positionVersionNum','front')
954:
955: if positionVersionNum=='front':
956: id="V%i"%self.getVersion()+"_"+self.title
957: else:
958: tmp=os.path.splitext(self.title)
959: if len(tmp)>1:
960: id=tmp[0]+"_V%i"%self.getVersion()+tmp[1]
961: else:
962: id=tmp[0]+"_V%i"%self.getVersion()
963:
964: manage_addextVersionedFileObject(self,id,vC,author,file,id,precondition, content_type)
965: objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
966: self.REQUEST.SESSION['objID_parent']=self.getId()
967:
968: if getattr(self,'defaultFileCatalog',None):
969:
970: self.reindex_object()
971:
972: if RESPONSE:
973: obj=self.ZopeFind(self,obj_ids=[id])[0][1]
974: if obj.getSize()==0:
975: self.REQUEST.SESSION['objID']=obj.getId()
976: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
977: return pt()
978:
979: else:
980: RESPONSE.redirect(self.REQUEST['URL2'])
981:
982: else:
983: return self.ZopeFind(self,obj_ids=[id])[0][1]
984:
985:
986: def download(self):
987: """download and lock"""
988: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
989: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
990: self.content_type="application/octet-stream"
991: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
992:
993: security.declareProtected('AUTHENTICATED_USER','downloadLocked')
994: def downloadLocked(self):
995: """download and lock"""
996:
997: if repr(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
998: return "please login first"
999: if not self.lockedBy=="":
1000: return "cannot be locked because is already locked by %s"%self.lockedBy
1001: self.lockedBy=self.REQUEST['AUTHENTICATED_USER']
1002: self.getLastVersion().content_type="application/octet-stream"
1003: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
1004:
1005: def manage_addextVersionedFileForm(self):
1006: """interface for adding the OSAS_root"""
1007: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addextVersionedFile.zpt')).__of__(self)
1008: return pt()
1009:
1010: def manage_addextVersionedFile(self,id,title,lockedBy, author=None, RESPONSE=None):
1011: """add the OSAS_root"""
1012: newObj=extVersionedFile(id,title,lockedBy,author)
1013: self._setObject(id,newObj)
1014:
1015: if RESPONSE is not None:
1016: RESPONSE.redirect('manage_main')
1017:
1018:
1019: InitializeClass(extVersionedFile)
1020: 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