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