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