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