File:  [Repository] / versionedFile / versionedFile.py
Revision 1.11: download - view: text, annotated - select for diffs - revision graph
Thu Jul 8 18:56:41 2004 UTC (19 years, 11 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
changename changed

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

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>