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: import os.path
11:
12: import time
13: try:
14: from Products.ECHO_content.ECHO_collection import ECHO_basis
15: except:
16: print "ECHO Elements not imported"
17: class ECHO_basis:
18: """leer"""
19: manage_options=()
20:
21:
22: def sortv(x,y):
23: return cmp(x[0],y[0])
24:
25: class versionedFileFolder(Folder,ECHO_basis):
26: """Folder with versioned files"""
27:
28:
29: meta_type = "versionedFileFolder"
30:
31: security= ClassSecurityInfo()
32: security.declareProtected('AUTHENTICATED_USER','addFileForm')
33:
34: if ECHO_basis:
35: optTMP= Folder.manage_options+ECHO_basis.manage_options
36: else:
37: optTMP= Folder.manage_options
38:
39: manage_options =optTMP+(
40: {'label':'Generate Index.html','action':'generateIndexHTML'},
41: {'label':'Generate history_template.html','action':'generateHistoryHTML'},
42: )
43:
44:
45:
46: def helpDownload(self):
47: """download help"""
48:
49: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','helpDownload')).__of__(self)
50: return pt()
51:
52: def generateIndexHTML(self,RESPONSE=None):
53: """lege standard index.html an"""
54:
55:
56: if not self.ZopeFind(self,obj_ids=['index.html']):
57: zt=ZopePageTemplate('index.html')
58: self._setObject('index.html',zt)
59: default_content_fn = os.path.join(package_home(globals()),
60: 'zpt/versionFileFolderMain.zpt')
61: text = open(default_content_fn).read()
62: zt.pt_edit(text, 'text/html')
63:
64: else:
65: return "already exists!"
66:
67: if RESPONSE is not None:
68: RESPONSE.redirect('manage_main')
69:
70:
71: def generateHistoryHTML(self,RESPONSE=None):
72: """lege standard index.html an"""
73:
74:
75:
76: if not self.ZopeFind(self,obj_ids=['history_template.html']):
77: zt=ZopePageTemplate('history_template.html')
78: self._setObject('history_template.html',zt)
79: default_content_fn = os.path.join(package_home(globals()),
80: 'zpt/versionHistory.zpt')
81: text = open(default_content_fn).read()
82: zt.pt_edit(text, 'text/html')
83:
84: else:
85: return "already exists!"
86:
87: if RESPONSE is not None:
88: RESPONSE.redirect('manage_main')
89:
90: def getVersionedFiles(self,sortField='title'):
91: """get all versioned files"""
92:
93: def sortName(x,y):
94: return cmp(x[1].title.lower(),y[1].title.lower())
95:
96: def sortDate(x,y):
97: return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
98:
99: def sortComment(x,y):
100: try:
101: x=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
102: except:
103: x='zzzzzzzzzzzzzzzz'
104: try:
105: y=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
106: except:
107: y='zzzzzzzzzzzzzzzz'
108: return cmp(x,y)
109:
110: def sortAuthor(x,y):
111:
112: return cmp(x[1].getLastVersion().lastEditor().lower(),y[1].getLastVersion().lastEditor().lower())
113:
114: versionedFiles=self.ZopeFind(self,obj_metatypes=['versionedFile'])
115:
116: if sortField=='title':
117: versionedFiles.sort(sortName)
118: elif sortField=='date':
119: versionedFiles.sort(sortDate)
120: elif sortField=='author':
121: versionedFiles.sort(sortAuthor)
122: elif sortField=='comment':
123: versionedFiles.sort(sortComment)
124:
125: return versionedFiles
126:
127:
128: def header_html(self):
129: """zusätzlicher header"""
130: ext=self.ZopeFind(self,obj_ids=["header.html"])
131: if ext:
132: return ext[0][1]()
133: else:
134: return ""
135:
136: def index_html(self):
137: """main"""
138: ext=self.ZopeFind(self,obj_ids=["index.html"])
139: if ext:
140: return ext[0][1]()
141:
142: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionFileFolderMain')).__of__(self)
143: return pt()
144:
145:
146: def addFileForm(self):
147: """add a file"""
148: ext=self.ZopeFind(self,obj_ids=["addFileForm.dtml"])
149: if ext:
150: return ext[0][1]('',globals(),version='1',AUTHENTICATED_USER=self.REQUEST.AUTHENTICATED_USER)
151:
152: out=DTMLFile('dtml/newFileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version='1').__of__(self)
153: return out()
154:
155:
156: def addFile(self,vC,file,author,newName='',content_type='',RESPONSE=None):
157: """ add a new file"""
158: if newName=='':
159: filename=file.filename
160: id=filename[max(filename.rfind('/'),
161: filename.rfind('\\'),
162: filename.rfind(':'),
163: )+1:]
164:
165: else:
166: id=newName
167:
168: vC=self.REQUEST.form['vC']
169: manage_addVersionedFile(self,id,'','')
170: #if (getattr(self,'commentNonEmpty',0)==1) and vC.strip()=="":
171:
172:
173: ob=self._getOb(id)
174: ob.title=id
175: file2=file
176:
177: obj=ob.manage_addVersionedFileObject(id,vC,author,file2,content_type=content_type)
178: self.REQUEST.SESSION['objID']=ob.getId()
179: self.REQUEST.SESSION['objID_parent']=None
180:
181: if obj.getSize()==0:
182: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
183: return pt()
184:
185: RESPONSE.redirect(self.REQUEST['URL1'])
186:
187:
188: def deleteEmptyObject(self,submit,RESPONSE=None):
189: """deleteemptyobject"""
190: if submit=="delete it":
191: if self.REQUEST.SESSION['objID_parent']:
192: obj=getattr(self,self.REQUEST.SESSION['objID_parent'])
193:
194: else:
195: obj=self
196: obj.manage_delObjects([self.REQUEST.SESSION['objID']])
197:
198: RESPONSE.redirect(self.REQUEST['URL1'])
199:
200:
201: manage_addVersionedFileFolderForm=DTMLFile('dtml/folderAdd', globals())
202:
203:
204: def manage_addVersionedFileFolder(self, id, title='',
205: createPublic=0,
206: createUserF=0,
207: REQUEST=None):
208: """Add a new Folder object with id *id*.
209:
210: If the 'createPublic' and 'createUserF' parameters are set to any true
211: value, an 'index_html' and a 'UserFolder' objects are created respectively
212: in the new folder.
213: """
214: ob=versionedFileFolder()
215: ob.id=str(id)
216: ob.title=title
217: self._setObject(id, ob)
218: ob=self._getOb(id)
219:
220: checkPermission=getSecurityManager().checkPermission
221:
222: if createUserF:
223: if not checkPermission('Add User Folders', ob):
224: raise Unauthorized, (
225: 'You are not authorized to add User Folders.'
226: )
227: ob.manage_addUserFolder()
228:
229:
230: if REQUEST is not None:
231: return self.manage_main(self, REQUEST, update_menu=1)
232:
233:
234:
235: class versionedFileObject(File):
236: """File Object im Folder"""
237:
238: meta_type = "versionedFileObject"
239:
240: manage_editForm =DTMLFile('dtml/fileEdit',globals(),
241: Kind='File',kind='file')
242: manage_editForm._setName('manage_editForm')
243:
244: def getTime(self):
245: """getTime"""
246: #return self.bobobase_modification_time().ISO()
247: if hasattr(self,'time'):
248: return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
249: elif hasattr(self,'timefixed'):
250: return self.timefixed
251: else:
252: setattr(self,'timefixed',self.bobobase_modification_time().ISO())
253: return self.bobobase_modification_time().ISO()
254:
255:
256:
257:
258:
259: def download(self):
260: """download and lock"""
261:
262:
263: self.content_type="application/octet-stream"
264: self.REQUEST.RESPONSE.redirect(self.absolute_url())
265:
266: def downloadLocked(self):
267: """download and lock"""
268:
269:
270: if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
271: return "please login first"
272: if not self.aq_parent.lockedBy=="":
273: return "cannot be locked because is already locked by %s"%self.lockedBy
274: self.aq_parent.lockedBy=self.REQUEST['AUTHENTICATED_USER']
275:
276: self.content_type="application/octet-stream"
277: self.REQUEST.RESPONSE.redirect(self.absolute_url())
278:
279: def setVersionNumber(self,versionNumber):
280: """set version"""
281: self.versionNumber=versionNumber
282:
283: def getVersionNumber(self):
284: """get version"""
285: return self.versionNumber
286:
287: def lastEditor(self):
288: """last Editor"""
289: if hasattr(self,'author'):
290: return self.author
291: else:
292: jar=self._p_jar
293: oid=self._p_oid
294:
295: if jar is None or oid is None: return None
296:
297: return jar.db().history(oid)[0]['user_name']
298:
299:
300:
301:
302: manage_addVersionedFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject', version='1')
303:
304: def manage_addVersionedFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
305: REQUEST=None):
306: """Add a new File object.
307:
308: Creates a new File object 'id' with the contents of 'file'"""
309:
310: id=str(id)
311: title=str(title)
312: content_type=str(content_type)
313: precondition=str(precondition)
314:
315: id, title = cookId(id, title, file)
316:
317: self=self.this()
318:
319: # First, we create the file without data:
320: self._setObject(id, versionedFileObject(id,title,'',content_type, precondition))
321: self._getOb(id).versionComment=str(vC)
322: self._getOb(id).time=time.localtime()
323:
324: setattr(self._getOb(id),'author',author)
325:
326: # Now we "upload" the data. By doing this in two steps, we
327: # can use a database trick to make the upload more efficient.
328: if file:
329: self._getOb(id).manage_upload(file)
330: if content_type:
331: self._getOb(id).content_type=content_type
332:
333: if REQUEST is not None:
334: REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
335:
336:
337:
338:
339: class versionedFile(Folder):
340: """Versioniertes File"""
341:
342: def __init__(self, id, title, lockedBy,author):
343: """init"""
344: self.id=id
345: self.title=title
346: self.lockedBy=lockedBy
347: self.author=author
348:
349:
350: meta_type="versionedFile"
351:
352: def manageCommentForm(self):
353: """add a comment"""
354: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addComment')).__of__(self)
355: return pt()
356:
357: def manageComment(self,text,comment_author,submit,REQUEST=None):
358: """manage comments"""
359: if submit =='change':
360: if text=='':
361: self.comment=None
362: else:
363: self.comment=text
364: self.comment_author=comment_author
365:
366: self.comment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
367:
368: return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
369:
370: def getLastVersion(self):
371: """Last Version"""
372: tmp=0
373: lastVersion=None
374:
375: for version in self.ZopeFind(self):
376:
377: if hasattr(version[1],'versionNumber'):
378:
379: if int(version[1].versionNumber) > tmp:
380: tmp=int(version[1].versionNumber,)
381: lastVersion=version[1]
382: return lastVersion
383:
384: def index_html(self):
385: """main view"""
386: lastVersion=self.getLastVersion()
387: #return "File:"+self.title+" Version:%i"%lastVersion.versionNumber," modified:",lastVersion.bobobase_modification_time()," size:",lastVersion.getSize(),"modified by:",lastVersion.lastEditor()
388: return "File: %s Version:%i modified:%s size:%s modified by:%s"%(self.title,lastVersion.versionNumber,lastVersion.getTime(),lastVersion.getSize(),lastVersion.lastEditor())
389:
390: def getVersion(self):
391: tmp=0
392: for version in self.ZopeFind(self):
393:
394: if hasattr(version[1],'versionNumber'):
395:
396: if int(version[1].versionNumber) > tmp:
397: tmp=int(version[1].versionNumber,)
398: return tmp+1
399:
400: security= ClassSecurityInfo()
401: security.declareProtected('AUTHENTICATED_USER','unlock')
402:
403: def history(self):
404: """history"""
405:
406: ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
407: if ext:
408: return getattr(self,ext[0][1].getId())()
409:
410: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
411: return pt()
412:
413: def getVersions(self):
414: """get all versions"""
415: ret=[]
416: for version in self.ZopeFind(self):
417: if hasattr(version[1],'versionNumber'):
418: ret.append((version[1].versionNumber,version[1]))
419: ret.sort(sortv)
420: return ret
421:
422: security.declareProtected('AUTHENTICATED_USER','forceunlock')
423: def forceunlock(self,RESPONSE):
424: """unlock"""
425: self.lockedBy=''
426:
427: security.declareProtected('AUTHENTICATED_USER','unlock')
428: def unlock(self,RESPONSE):
429: """unlock"""
430: if str(self.lockedBy) in [str(self.REQUEST['AUTHENTICATED_USER'])]:
431: self.lockedBy=''
432: RESPONSE.redirect(self.REQUEST['URL2'])
433: else:
434: return "Sorry, not locked by you! (%s,%s)"%(self.lockedBy,self.REQUEST['AUTHENTICATED_USER'])
435:
436:
437:
438: security.declareProtected('AUTHENTICATED_USER','addVersionedFileObjectForm')
439:
440: def addVersionedFileObjectForm(self):
441: """add a new version"""
442:
443: if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
444: return "please login first"
445: if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
446: out=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version=self.getVersion()).__of__(self)
447: return out()
448: else:
449: return "Sorry file is locked by somebody else"
450:
451: def manage_addVersionedFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
452: """add"""
453:
454: vC=self.REQUEST['vC']
455: author=self.REQUEST['author']
456:
457: if changeName=="yes":
458: filename=file.filename
459: self.title=filename[max(filename.rfind('/'),
460: filename.rfind('\\'),
461: filename.rfind(':'),
462: )+1:]
463:
464:
465: if not newName=='':
466: self.title=newName[0:]
467:
468: id="V%i"%self.getVersion()+"_"+self.title
469:
470: manage_addVersionedFileObject(self,id,vC,author,file,"V%i"%self.getVersion()+"_"+self.title,precondition, content_type)
471: objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
472: self.REQUEST.SESSION['objID_parent']=self.getId()
473:
474: if RESPONSE:
475: obj=self.ZopeFind(self,obj_ids=[id])[0][1]
476: if obj.getSize()==0:
477: self.REQUEST.SESSION['objID']=obj.getId()
478: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
479: return pt()
480:
481: else:
482: RESPONSE.redirect(self.REQUEST['URL2'])
483:
484: else:
485: return self.ZopeFind(self,obj_ids=[id])[0][1]
486:
487: security.declareProtected('AUTHENTICATED_USER','downloadLocked')
488:
489: def download(self):
490: """download and lock"""
491: self.getLastVersion().content_type="application/octet-stream"
492: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
493:
494: def downloadLocked(self):
495: """download and lock"""
496: if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
497: return "please login first"
498: if not self.lockedBy=="":
499: return "cannot be locked because is already locked by %s"%self.lockedBy
500: self.lockedBy=self.REQUEST['AUTHENTICATED_USER']
501: self.getLastVersion().content_type="application/octet-stream"
502: self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
503:
504: def manage_addVersionedFileForm(self):
505: """interface for adding the OSAS_root"""
506: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addVersionedFile.zpt')).__of__(self)
507: return pt()
508:
509: def manage_addVersionedFile(self,id,title,lockedBy, author=None, RESPONSE=None):
510: """add the OSAS_root"""
511: newObj=versionedFile(id,title,lockedBy,author)
512: self._setObject(id,newObj)
513:
514: if RESPONSE is not None:
515: RESPONSE.redirect('manage_main')
516:
517:
518: InitializeClass(versionedFile)
519: 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