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