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