File:  [Repository] / versionedFile / versionedFile.py
Revision 1.19: download - view: text, annotated - select for diffs - revision graph
Tue Nov 23 13:09:27 2004 UTC (19 years, 6 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD

echo support addedCVS: ----------------------------------------------------------------------

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

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