Return to versionedFile.py CVS log

Up to [Repository] / versionedFile

header eingefuegt

    1: from OFS.Folder import Folder
    2: from OFS.Image import File
    3: from OFS.Image import cookId
    4: from Globals import DTMLFile, InitializeClass
    5: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    6: from AccessControl import getSecurityManager
    7: from Products.PageTemplates.PageTemplate import PageTemplate
    8: from AccessControl import ClassSecurityInfo
    9: 
   10: def sortv(x,y):
   11:     return cmp(x[0],y[0])
   12:  
   13: class versionedFileFolder(Folder):
   14:     """Folder with versioned files"""
   15: 
   16:     meta_type = "versionedFileFolder"
   17: 
   18:     security= ClassSecurityInfo()
   19:     security.declareProtected('AUTHENTICATED_USER','addFileForm')
   20:     
   21:     def getVersionedFiles(self):
   22:         """get all versioned files"""
   23:         
   24: 	versionedFiles=self.ZopeFind(self,obj_metatypes=['versionedFile'])
   25:        
   26:         return versionedFiles
   27: 
   28: 
   29:     def header_html(self):
   30:         """zusätzlicher header"""
   31:         ext=self.ZopeFind(self,obj_ids=["header.html"])
   32:         if ext:
   33:             return ext[0][1]()
   34:         else:
   35:             return ""
   36:         
   37:     def index_html(self):
   38:         """main"""
   39:         ext=self.ZopeFind(self,obj_ids=["index.html"])
   40:         if ext:
   41:             return ext[0]
   42:         
   43:         pt=PageTemplateFile('Products/versionedFile/zpt/versionFileFolderMain').__of__(self)
   44:         return pt()
   45: 
   46: 
   47:     def addFileForm(self):
   48:         """add a file"""
   49:         out=DTMLFile('dtml/newFileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version='1').__of__(self)
   50:         return out()
   51: 
   52: 
   53:     def addFile(self,vC,file,content_type='',RESPONSE=None):
   54:         """ add a new file"""
   55:         id=file.filename
   56:         
   57:         vC=self.REQUEST.form['vC']
   58:         manage_addVersionedFile(self,id,'','')
   59:         ob=self._getOb(id)
   60:         ob.title=id
   61:         file2=file
   62:         ob.manage_addVersionedFileObject(id,vC,file2,content_type=content_type)
   63: 
   64:         RESPONSE.redirect(self.REQUEST['URL1'])
   65: 
   66:         
   67: manage_addVersionedFileFolderForm=DTMLFile('dtml/folderAdd', globals())
   68: 
   69: 
   70: def manage_addVersionedFileFolder(self, id, title='',
   71:                      createPublic=0,
   72:                      createUserF=0,
   73:                      REQUEST=None):
   74:     """Add a new Folder object with id *id*.
   75: 
   76:     If the 'createPublic' and 'createUserF' parameters are set to any true
   77:     value, an 'index_html' and a 'UserFolder' objects are created respectively
   78:     in the new folder.
   79:     """
   80:     ob=versionedFileFolder()
   81:     ob.id=str(id)
   82:     ob.title=title
   83:     self._setObject(id, ob)
   84:     ob=self._getOb(id)
   85: 
   86:     checkPermission=getSecurityManager().checkPermission
   87: 
   88:     if createUserF:
   89:         if not checkPermission('Add User Folders', ob):
   90:             raise Unauthorized, (
   91:                   'You are not authorized to add User Folders.'
   92:                   )
   93:         ob.manage_addUserFolder()
   94: 
   95:   
   96:     if REQUEST is not None:
   97:         return self.manage_main(self, REQUEST, update_menu=1)
   98: 
   99: 
  100: 
  101: class versionedFileObject(File):
  102:     """File Object im Folder"""
  103:     
  104:     meta_type = "versionedFileObject"
  105:     
  106:     manage_editForm  =DTMLFile('dtml/fileEdit',globals(),
  107:                                Kind='File',kind='file')
  108:     manage_editForm._setName('manage_editForm')
  109: 
  110: 
  111:     def setVersionNumber(self,versionNumber):
  112:         """set version"""
  113:         self.versionNumber=versionNumber
  114: 
  115:     def getVersionNumber(self):
  116:         """get version"""
  117:         return self.versionNumber
  118: 
  119:     def lastEditor(self):
  120:         """last Editor"""
  121:         jar=self._p_jar
  122:         oid=self._p_oid
  123:         if jar is None or oid is None: return None
  124:         return jar.db().history(oid)[0]['user_name']
  125: 
  126:     
  127:     
  128:         
  129: manage_addVersionedFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject', version='1')
  130: 
  131: def manage_addVersionedFileObject(self,id,vC='',file='',title='',precondition='', content_type='',
  132:                    REQUEST=None):
  133:     """Add a new File object.
  134: 
  135:     Creates a new File object 'id' with the contents of 'file'"""
  136:     
  137:     id=str(id)
  138:     title=str(title)
  139:     content_type=str(content_type)
  140:     precondition=str(precondition)
  141:     
  142:     id, title = cookId(id, title, file)
  143: 
  144:     self=self.this()
  145: 
  146:     # First, we create the file without data:
  147:     self._setObject(id, versionedFileObject(id,title,'',content_type, precondition))
  148:     self._getOb(id).versionComment=str(vC)
  149:     
  150:     # Now we "upload" the data.  By doing this in two steps, we
  151:     # can use a database trick to make the upload more efficient.
  152:     if file:
  153:         self._getOb(id).manage_upload(file)
  154:     if content_type:
  155:         self._getOb(id).content_type=content_type
  156: 
  157:     if REQUEST is not None:
  158:         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
  159: 
  160: 
  161: 
  162: 
  163: class versionedFile(Folder):
  164:     """Versioniertes File"""
  165: 
  166:     def __init__(self, id, title, lockedBy):
  167:         """init"""
  168:         self.id=id
  169:         self.title=title
  170:         self.lockedBy=lockedBy
  171:         
  172:     meta_type="versionedFile"
  173: 
  174:     def getLastVersion(self):
  175:         """Last Version"""
  176:         tmp=0
  177:         lastVersion=None
  178:         
  179:         for version in self.ZopeFind(self):
  180:             
  181:             if hasattr(version[1],'versionNumber'):
  182:                 
  183:                 if int(version[1].versionNumber) > tmp:
  184:                     tmp=int(version[1].versionNumber,)
  185:                     lastVersion=version[1]
  186:         return lastVersion
  187:     
  188:     def index_html(self):
  189:         """main view"""
  190:         lastVersion=self.getLastVersion()
  191:         #return "File:"+self.title+"  Version:%i"%lastVersion.versionNumber," modified:",lastVersion.bobobase_modification_time()," size:",lastVersion.getSize(),"modified by:",lastVersion.lastEditor()
  192:         return "File: %s Version:%i modified:%s size:%s modified by:%s"%(self.title,lastVersion.versionNumber,lastVersion.bobobase_modification_time(),lastVersion.getSize(),lastVersion.lastEditor())
  193:                                                                          
  194:     def getVersion(self):
  195:         tmp=0
  196:         for version in self.ZopeFind(self):
  197:             
  198:             if hasattr(version[1],'versionNumber'):
  199:                 
  200:                 if int(version[1].versionNumber) > tmp:
  201:                     tmp=int(version[1].versionNumber,)
  202:         return tmp+1
  203: 
  204:     security= ClassSecurityInfo()
  205:     security.declareProtected('AUTHENTICATED_USER','unlock')
  206: 
  207:     def history(self):
  208:         """history"""
  209:         pt=PageTemplateFile('Products/versionedFile/zpt/versionHistory').__of__(self)
  210:         return pt()
  211: 
  212:     def getVersions(self):
  213:         """get all versions"""
  214:         ret=[]
  215:         for version in self.ZopeFind(self):
  216:             if hasattr(version[1],'versionNumber'):
  217:                 ret.append((version[1].versionNumber,version[1]))
  218:         ret.sort(sortv)
  219:         return ret
  220: 
  221:         
  222:     def unlock(self,RESPONSE):
  223:         """unlock"""
  224:         if str(self.lockedBy) in [str(self.REQUEST['AUTHENTICATED_USER'])]:
  225:             self.lockedBy=''
  226:             RESPONSE.redirect(self.REQUEST['URL2'])
  227:         else:
  228:             return "Sorry, not locked by you! (%s,%s)"%(self.lockedBy,self.REQUEST['AUTHENTICATED_USER'])
  229:         
  230:     security= ClassSecurityInfo()
  231:     security.declareProtected('AUTHENTICATED_USER','addVersionedFileObjectForm')
  232: 
  233:     def addVersionedFileObjectForm(self):
  234:         """add a new version"""
  235:         
  236:         if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
  237:             return "please login first"
  238:         if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
  239:             out=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version=self.getVersion()).__of__(self)
  240:             return out()
  241:         else:
  242:             return "Sorry file is locked by somebody else"
  243:         
  244:     def manage_addVersionedFileObject(self,id,vC,file='',title='',precondition='', content_type='',RESPONSE=None):
  245:         """add"""
  246:         
  247:         vC=self.REQUEST['vC']
  248:         id="V%i"%self.getVersion()+"_"+self.title
  249:         manage_addVersionedFileObject(self,id,vC,file,"V%i"%self.getVersion()+"_"+self.title,precondition, content_type)
  250:         objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
  251: 
  252:         if RESPONSE:
  253:             RESPONSE.redirect(self.REQUEST['URL2'])
  254: 
  255:     security.declareProtected('AUTHENTICATED_USER','downloadLocked')
  256: 
  257:     def downloadLocked(self):
  258:         """download and lock"""
  259:         if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
  260:             return "please login first"
  261:         if not self.lockedBy=="":
  262:             return "cannot be locked because is already locked by %s"%self.lockedBy
  263:         self.lockedBy=self.REQUEST['AUTHENTICATED_USER']
  264:         
  265:         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
  266:     
  267: def manage_addVersionedFileForm(self):
  268:     """interface for adding the OSAS_root"""
  269:     pt=PageTemplateFile('Products/versionedFile/zpt/addVersionedFile.zpt').__of__(self)
  270:     return pt()
  271: 
  272: def manage_addVersionedFile(self,id,title,lockedBy, RESPONSE=None):
  273:     """add the OSAS_root"""
  274:     newObj=versionedFile(id,title,lockedBy)
  275:     self._setObject(id,newObj)
  276:     if RESPONSE is not None:
  277:         RESPONSE.redirect('manage_main')
  278: 
  279: 
  280: InitializeClass(versionedFile)
  281: InitializeClass(versionedFileFolder)