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