File:  [Repository] / versionedFile / versionedFile.py
Revision 1.50: download - view: text, annotated - select for diffs - revision graph
Wed Nov 2 12:38:52 2005 UTC (18 years, 7 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
versiones

    1: 
    2: from OFS.Folder import Folder
    3: from OFS.Image import File
    4: from OFS.Image import cookId
    5: from Globals import DTMLFile, InitializeClass,package_home
    6: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    7: from AccessControl import getSecurityManager
    8: from Products.PageTemplates.PageTemplate import PageTemplate
    9: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   10: from AccessControl import ClassSecurityInfo
   11: <<<<<<< versionedFile.py
   12: from Products.ImageArchive.ImageArchive import manage_AddImageZogiLib
   13: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   14: =======
   15: try:
   16:  from Products.ImageArchive.ImageArchive import manage_AddImageZogiLib
   17: except:
   18:  print "no images"
   19: >>>>>>> 1.49
   20: 
   21: from threading import Thread
   22: import shutil
   23: import tempfile
   24: import os.path
   25: import urllib
   26: 
   27: import time
   28: try:
   29:     from Products.ECHO_content.ECHO_collection import ECHO_basis
   30: except:
   31:     print "ECHO Elements not imported"
   32:     class ECHO_basis:
   33: 	     """leer"""
   34:     	     manage_options=()
   35: 
   36: 	
   37: def sortv(x,y):
   38:     return cmp(x[0],y[0])
   39: tdir = "/tmp/downloadVersionedFiles"
   40: 
   41: class generateDownloadZip:
   42:     """generateDownloadSet"""
   43: 
   44:     def __init__(self,folderObject,url):
   45:         """init downloadzip"""
   46:         self.folder=folderObject
   47:         self.done=None
   48:         self.response=""
   49:         self.url=url
   50:         
   51:     def __call__(self):
   52:         """call generate download zip"""
   53:         storeTempDir=tempfile.tempdir
   54: 	tempfile.tempdir=tdir
   55: 
   56:         tmpPath=tempfile.mktemp()
   57:         tmpZip=tempfile.mktemp()+".gtz"
   58:         tmpFn=os.path.split(tmpZip)[1]
   59:         
   60:         if not os.path.exists(tempfile.tempdir):
   61:             os.mkdir(tempfile.tempdir) 
   62: 
   63:         if not os.path.exists(tmpPath):
   64: 		    os.mkdir(tmpPath) 
   65: 	    
   66: 	self.response="<h3>1. step: getting the files</h3>"
   67: 
   68:         for files in self.folder.ZopeFind(self.folder,obj_metatypes=['versionedFile']):
   69:             lastV=files[1].getLastVersion()
   70:             self.response+=str("<p>Get File: %s<br>\n"%lastV.title)
   71: 
   72:             savePath=os.path.join(tmpPath,lastV.title)
   73:             fh=file(savePath,"w")
   74:             fh.write(lastV.data)
   75:             fh.close()
   76: 
   77:         self.response+="<h3>2. step: creating the downloadable file</h3>"
   78: 	self.response+="<p>Create gtar<br>"
   79:         self.response+="<p>This can take a while....<br>\n"
   80: 
   81:         fh=os.popen2("tar zcvf %s %s/*"%(tmpZip,tmpPath),1)[1]
   82:         self.response+="<br>"
   83:         for c in fh.read():
   84:             self.response+=c
   85:             if c==")":
   86:                 self.response+="<br>\n"
   87: 		    
   88: 			    
   89: 
   90:         
   91:         shutil.rmtree(tmpPath)
   92: 
   93:         self.response+="<p>finished<br>\n"
   94: 
   95:         len=os.stat(tmpZip)[6]
   96:         downloadUrl=self.url+"/downloadSet"
   97:         self.response+="""<h1><a href="downloadSet?fn=%s">Click here for download ( %i Byte)</a></h1>\n"""%(tmpFn,len)
   98:         self.response+="""<p>The file you receive is a tar (gnutar) compressed file, after unpacking you will find a new folder <emph>tmp</emph> where the files are stored in.</p>"""
   99:         self.response+="""<p>The file will be stored for a while, you can download it later, the URL is:</p>
  100: 		    <p><a href="downloadSet?fn=%s">%s?fn=%s</a></h1>\n"""%(tmpFn,downloadUrl,tmpFn)
  101: 
  102:         self.done=True
  103: 
  104:  
  105:     def getResult(self):
  106:         """get result"""
  107:         return self.response
  108: 
  109:     def isDone(self):
  110:         if self.done:
  111:             return True
  112:         else:
  113:             return False
  114:         
  115: 
  116: class versionedFileFolder(Folder,ECHO_basis):
  117:     """Folder with versioned files"""
  118: 
  119:     
  120:     meta_type = "versionedFileFolder"
  121: 
  122:     security= ClassSecurityInfo()
  123:     security.declareProtected('AUTHENTICATED_USER','addFileForm')
  124:     filesMetaType=['versionedFile']
  125:     if ECHO_basis:
  126:         optTMP= Folder.manage_options+ECHO_basis.manage_options
  127:     else:
  128:         optTMP= Folder.manage_options
  129: 
  130:     manage_options =optTMP+(
  131: 		{'label':'Generate Index.html','action':'generateIndexHTML'},
  132:                 {'label':'Generate Image Index.html','action':'generateIndexHTML_image'},
  133:                 {'label':'Generate history_template.html','action':'generateHistoryHTML'},
  134:                 {'label':'Import Folder','action':'importFolderForm'},
  135:                 {'label':'Export Folder','action':'exportFolder'},
  136:                 )
  137: 
  138:     def importFolderForm(self):
  139:         """form fuer folder import"""
  140:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','importFolderForm.zpt')).__of__(self)
  141:         return pt()
  142:         
  143:     def importFolder(self,path,comment="",author=None,lockedBy=None,RESPONSE=None):
  144:         """importiere inhalt eines folders"""
  145: 
  146:         for fileName in os.listdir(path):
  147:             if os.path.isfile(os.path.join(path,fileName)):
  148:                 manage_addVersionedFile(self,fileName,'','')
  149:                 id=fileName
  150:                 ob=self._getOb(fileName)
  151:                 ob.title=id
  152:                 file2=file(os.path.join(path,fileName))
  153:         
  154:                 obj=ob.manage_addVersionedFileObject(id,comment,author,file2,content_type='')
  155: 
  156:         if RESPONSE:
  157:             RESPONSE.redirect(self.REQUEST['URL1'])
  158: 
  159:     zipThreads={}
  160:     zipThreads2={}
  161: 
  162:     def refreshTxt(self):
  163:         """txt fuer refresh"""
  164:         tn=self.REQUEST.SESSION['threadName']
  165:         return """ 2;url=%s?repeat=%s """%(self.absolute_url()+"/exportFolder",tn)
  166: 
  167:     def exportFolder(self,repeat=None):
  168:         """exportiert alle akutellen files des folders"""
  169:         threadName=repeat
  170:         
  171:         downloadZip=generateDownloadZip(self,self.absolute_url())
  172:         downloadZip()
  173:         return downloadZip.getResult()
  174:        ##  if not threadName or threadName=="":
  175: ##             threadStart=generateDownloadZip(self,self.absolute_url())
  176: ##             thread=Thread(target=threadStart)
  177:             
  178: ##             thread.start()
  179: 
  180:                     
  181: ##             self.zipThreads[thread.getName()[0:]]=threadStart
  182: ##             self.zipThreads2[thread.getName()[0:]]=thread
  183: ##             self.REQUEST.SESSION['threadName']=thread.getName()[0:]
  184: ##             wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['zip_wait_template'])
  185: ##             if wait_template:
  186: ##                 return wait_template[0][1]()
  187: ##             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
  188: ##             return pt()
  189:                 
  190: ##         else:
  191: ##             self.REQUEST.SESSION['threadName']=threadName
  192: 
  193: ##             if (self.zipThreads[threadName].getResult()==None):
  194: 
  195: ##                 wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
  196: ##                 if wait_template:
  197: ##                     return wait_template[0][1]()
  198: 
  199: ##                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait.zpt')).__of__(self)
  200: ##                 return pt()
  201: ##             else:
  202: ##                 if self.zipThreads[threadName].isDone():
  203: ##                     self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
  204: ##                     self.zipThreads2[threadName].join()
  205: ##                     del(self.zipThreads2[threadName])
  206: ##                     del(self.zipThreads[threadName])
  207: ##                     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_result.zpt')).__of__(self)
  208: ##                     return pt()
  209: 
  210: ##                 else:
  211: ##                     self.REQUEST.SESSION['result']=self.zipThreads[threadName].getResult()
  212: ##                     self.REQUEST.SESSION['threadName']=threadName
  213: ##                     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','zip_wait_result.zpt')).__of__(self)
  214: ##                     return pt()
  215: 
  216:     def downloadSet(self,fn):
  217: 	    """download prepared set"""
  218: 	    filename=os.path.join(tdir,fn)
  219: 
  220: 	    
  221: 	    self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s" """%"downloadFileFolder.tgz")
  222: 	    self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
  223: 	    len=os.stat(filename)[6]
  224: 	    self.REQUEST.RESPONSE.setHeader("Content-Length",len)
  225: 	    images=file(filename).read()
  226: 	    self.REQUEST.RESPONSE.write(images)
  227: 	    self.REQUEST.RESPONSE.close()
  228: 
  229: 	
  230: 
  231:     def helpDownload(self):
  232:         """download help"""
  233:         
  234:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','helpDownload')).__of__(self)
  235:         return pt()
  236:     
  237:     def generateIndexHTML_image(self,RESPONSE=None):
  238:         """lege standard index.html an"""
  239: 
  240: 
  241:         if not self.ZopeFind(self,obj_ids=['index.html']):
  242:             zt=ZopePageTemplate('index.html')
  243:             self._setObject('index.html',zt)
  244:             default_content_fn = os.path.join(package_home(globals()),
  245:                                                'zpt/versionFileFolderMain_image.zpt')
  246:             text = open(default_content_fn).read()
  247:             zt.pt_edit(text, 'text/html')
  248: 
  249:         else:
  250:             return "already exists!"
  251:         
  252:         if RESPONSE is not None:
  253:             RESPONSE.redirect('manage_main')
  254: 
  255:     def generateIndexHTML(self,RESPONSE=None):
  256:         """lege standard index.html an"""
  257: 
  258: 
  259:         if not self.ZopeFind(self,obj_ids=['index.html']):
  260:             zt=ZopePageTemplate('index.html')
  261:             self._setObject('index.html',zt)
  262:             default_content_fn = os.path.join(package_home(globals()),
  263:                                                'zpt/versionFileFolderMain.zpt')
  264:             text = open(default_content_fn).read()
  265:             zt.pt_edit(text, 'text/html')
  266: 
  267:         else:
  268:             return "already exists!"
  269:         
  270:         if RESPONSE is not None:
  271:             RESPONSE.redirect('manage_main')
  272: 
  273: 
  274:     def generateHistoryHTML(self,RESPONSE=None):
  275:         """lege standard index.html an"""
  276: 
  277:         
  278: 
  279:         if not self.ZopeFind(self,obj_ids=['history_template.html']):
  280:             zt=ZopePageTemplate('history_template.html')
  281:             self._setObject('history_template.html',zt)
  282:             default_content_fn = os.path.join(package_home(globals()),
  283:                                                'zpt/versionHistory.zpt')
  284:             text = open(default_content_fn).read()
  285:             zt.pt_edit(text, 'text/html')
  286: 
  287:         else:
  288:             return "already exists!"
  289:         
  290:         if RESPONSE is not None:
  291:             RESPONSE.redirect('manage_main')
  292: 
  293:     
  294:        
  295: 
  296:     def getVersionedFiles(self,sortField='title'):
  297:         """get all versioned files"""
  298: 
  299:         def sortName(x,y):
  300:             return cmp(x[1].title.lower(),y[1].title.lower())
  301: 
  302:         def sortDate(x,y):
  303:             return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
  304: 
  305:         
  306:         def sortComment(x,y):
  307: 
  308:         
  309:             
  310: 	 try:
  311: 	    xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
  312: 	 except:
  313: 	    xc='ZZZZZZZZZZZZZ'.lower()
  314: 	 try:
  315: 	    yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
  316:          except:
  317:             yc='ZZZZZZZZZZZZZ'.lower()
  318: 
  319: 
  320:          if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
  321:              
  322:              try:
  323:                  xc=x[1].getLastVersion().getVComment().lower()
  324:              except:
  325:                  xc='ZZZZZZZZZZZZZ'.lower()
  326:                  
  327:          if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
  328:              try:
  329:                  yc=y[1].getLastVersion().getVComment().lower()
  330:              except:
  331:                  yc='ZZZZZZZZZZZZZ'.lower()
  332: 
  333:          
  334:          return cmp(xc,yc)
  335: 
  336:         def sortAuthor(x,y):
  337:             
  338:             return cmp(x[1].getLastVersion().lastEditor().lower(),y[1].getLastVersion().lastEditor().lower())
  339:         
  340:         versionedFiles=self.ZopeFind(self,obj_metatypes=self.filesMetaType)
  341:         
  342:         
  343:         if sortField=='title':
  344:             versionedFiles.sort(sortName)
  345:         elif sortField=='date':
  346:             versionedFiles.sort(sortDate)
  347:         elif sortField=='author':
  348:             versionedFiles.sort(sortAuthor)
  349:         elif sortField=='comment':
  350:             versionedFiles.sort(sortComment)
  351: 
  352:         return versionedFiles
  353: 
  354: 
  355:     def header_html(self):
  356:         """zusätzlicher header"""
  357:         ext=self.ZopeFind(self,obj_ids=["header.html"])
  358:         if ext:
  359:             return ext[0][1]()
  360:         else:
  361:             return ""
  362: 
  363: 
  364:     security.declareProtected('View','index_html')
  365:     def index_html(self):
  366:         """main"""
  367:         ext=self.ZopeFind(self,obj_ids=["index.html"])
  368:         if ext:
  369:             return ext[0][1]()
  370:         
  371:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionFileFolderMain')).__of__(self)
  372:         return pt()
  373: 
  374: 
  375:     def addFileForm(self):
  376:         """add a file"""
  377:         ext=self.ZopeFind(self,obj_ids=["addFileForm.dtml"])
  378:         if ext:
  379:             return ext[0][1]('',globals(),version='1',AUTHENTICATED_USER=self.REQUEST.AUTHENTICATED_USER)
  380:         
  381:         out=DTMLFile('dtml/newFileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version='1').__of__(self)
  382:         return out()
  383: 
  384: 
  385:     def addFile(self,vC,file,author,newName='',content_type='',RESPONSE=None):
  386:         """ add a new file"""
  387:         if newName=='':
  388:             filename=file.filename
  389:             id=filename[max(filename.rfind('/'),
  390:                                     filename.rfind('\\'),
  391:                                     filename.rfind(':'),
  392:                                     )+1:]
  393: 
  394:         else:
  395:             id=newName
  396:         
  397:         vC=self.REQUEST.form['vC']
  398:         manage_addVersionedFile(self,id,'','')
  399:         #if (getattr(self,'commentNonEmpty',0)==1) and vC.strip()=="":
  400:             
  401:             
  402:         ob=self._getOb(id)
  403:         ob.title=id
  404:         file2=file
  405:         
  406:         obj=ob.manage_addVersionedFileObject(id,vC,author,file2,content_type=content_type)
  407:         self.REQUEST.SESSION['objID']=ob.getId()
  408:         self.REQUEST.SESSION['objID_parent']=None
  409: 
  410:         if obj.getSize()==0:
  411:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
  412:             return pt()
  413:         
  414:         RESPONSE.redirect(self.REQUEST['URL1'])
  415: 
  416: 
  417:     def deleteEmptyObject(self,submit,RESPONSE=None):
  418:         """deleteemptyobject"""
  419:         if submit=="delete it":
  420:             if self.REQUEST.SESSION['objID_parent']:
  421:                 obj=getattr(self,self.REQUEST.SESSION['objID_parent'])
  422: 
  423:             else:
  424:                 obj=self
  425:             obj.manage_delObjects([self.REQUEST.SESSION['objID']])
  426: 
  427:         RESPONSE.redirect(self.REQUEST['URL1'])
  428:         
  429:         
  430: manage_addVersionedFileFolderForm=DTMLFile('dtml/folderAdd', globals())
  431: 
  432: 
  433: def manage_addVersionedFileFolder(self, id, title='',
  434:                      createPublic=0,
  435:                      createUserF=0,
  436:                      REQUEST=None):
  437:     """Add a new Folder object with id *id*.
  438: 
  439:     If the 'createPublic' and 'createUserF' parameters are set to any true
  440:     value, an 'index_html' and a 'UserFolder' objects are created respectively
  441:     in the new folder.
  442:     """
  443:     ob=versionedFileFolder()
  444:     ob.id=str(id)
  445:     ob.title=title
  446:     self._setObject(id, ob)
  447:     ob=self._getOb(id)
  448: 
  449:     checkPermission=getSecurityManager().checkPermission
  450: 
  451:     if createUserF:
  452:         if not checkPermission('Add User Folders', ob):
  453:             raise Unauthorized, (
  454:                   'You are not authorized to add User Folders.'
  455:                   )
  456:         ob.manage_addUserFolder()
  457: 
  458:   
  459:     if REQUEST is not None:
  460:         return self.manage_main(self, REQUEST, update_menu=1)
  461: 
  462: 
  463: 
  464: class versionedFileObject(File):
  465:     """File Object im Folder"""
  466:     security= ClassSecurityInfo()
  467:     meta_type = "versionedFileObject"
  468:     
  469:     manage_editForm  =DTMLFile('dtml/fileEdit',globals(),
  470:                                Kind='File',kind='file')
  471:     manage_editForm._setName('manage_editForm')
  472: <<<<<<< versionedFile.py
  473: 
  474:     security.declarePublic('getVComment')
  475: =======
  476:     security= ClassSecurityInfo()
  477: 
  478: >>>>>>> 1.49
  479:     def getVComment(self):
  480:         """get the comment of this file"""
  481:         if not hasattr(self,'vComment') or (not self.vComment) or (self.vComment.lstrip()==""):
  482:             return "Add comment"
  483: 
  484:         else:
  485:             return self.vComment
  486:             
  487:     def manageVCommentForm(self):
  488:         """add a comment"""
  489: 
  490:         self.REQUEST.SESSION['refer']=self.REQUEST['HTTP_REFERER']
  491: 
  492: 
  493:         
  494:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addVComment')).__of__(self)
  495:         return pt()
  496: 
  497:     def manageVComment(self,text,comment_author,submit,REQUEST=None):
  498:         """manage comments"""
  499:         if submit =='change':
  500:             if text=='':
  501:                 self.vComment=None
  502:             else:
  503:                 self.vComment=text
  504:                 self.vComment_author=comment_author
  505: 
  506:                 self.vComment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
  507: 
  508:         if self.REQUEST.SESSION.has_key('refer'):
  509: 
  510:             return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
  511:         return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url()+"/history")
  512:     
  513: <<<<<<< versionedFile.py
  514:     security.declarePublic('getVersionComment')
  515:     def getVersionComment(self):
  516:         """getversioncomment"""
  517:         return self.versionComment
  518:     
  519:     security.declarePublic('getTime')
  520: =======
  521:     security.declarePublic('getTime')                                              
  522: >>>>>>> 1.49
  523:     def getTime(self):
  524:         """getTime"""
  525:         #return self.bobobase_modification_time().ISO()
  526:         if hasattr(self,'time'):
  527:             return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
  528: 	elif hasattr(self,'timefixed'):
  529: 	    return self.timefixed
  530:         else:
  531: 	    setattr(self,'timefixed',self.bobobase_modification_time().ISO())
  532:             return self.bobobase_modification_time().ISO()
  533: 
  534: 
  535: 
  536:     
  537: 
  538:     def download(self,REQUEST=None,RESPONSE=None):
  539:         """download and lock"""
  540:         
  541:         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getId())
  542:         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
  543: 	#try:
  544: 	#	txt=self.index_html()
  545: 	#except:
  546: 	#	txt=self.index_html(REQUEST,RESPONSE)
  547: 	#
  548: 	#self.REQUEST.RESPONSE.setHeader("Content-Length","str(len(txt)+1000)")
  549:       	
  550:         self.content_type="application/octet-stream"
  551:         self.REQUEST.RESPONSE.redirect(self.absolute_url())
  552:         #txt=urllib.urlopen(self.absolute_url()).read()
  553:         #self.REQUEST.RESPONSE.write(txt)
  554: 	
  555: 
  556:         #self.REQUEST.close()
  557:     
  558:     def downloadLocked(self):
  559:         """download and lock"""
  560:         
  561:         
  562:         if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
  563:             return "please login first"
  564:         if not self.aq_parent.lockedBy=="":
  565:             return "cannot be locked because is already locked by %s"%self.lockedBy
  566:         self.aq_parent.lockedBy=self.REQUEST['AUTHENTICATED_USER']
  567: 
  568:         self.content_type="application/octet-stream"
  569:         self.REQUEST.RESPONSE.redirect(self.absolute_url())
  570:     
  571:     def setVersionNumber(self,versionNumber):
  572:         """set version"""
  573:         self.versionNumber=versionNumber
  574: 
  575: <<<<<<< versionedFile.py
  576: 
  577:     security.declarePublic('getVersionNumber')
  578: =======
  579:     security.declarePublic('getVersionNumber')                                              
  580: >>>>>>> 1.49
  581:     def getVersionNumber(self):
  582:         """get version"""
  583:         return self.versionNumber
  584: 
  585:     security.declarePublic('getVersionComment')                                              
  586:     def getVersionComment(self):
  587:         """get version"""
  588:         return self.versionComment
  589: 
  590:    
  591: <<<<<<< versionedFile.py
  592:     security.declarePublic('lastEditor')         
  593: =======
  594:     security.declarePublic('lastEditor')                                              	
  595: >>>>>>> 1.49
  596:     def lastEditor(self):
  597:         """last Editor"""
  598:         if hasattr(self,'author'):
  599:             ret=self.author.replace("-","\n")
  600:             ret=ret.replace("\r","\n")
  601:             return ret
  602: 
  603:         else:
  604:             jar=self._p_jar
  605:             oid=self._p_oid
  606: 
  607:             if jar is None or oid is None: return None
  608: 
  609:             return jar.db().history(oid)[0]['user_name']
  610: 
  611:     
  612:     
  613:         
  614: manage_addVersionedFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject', version='1')
  615: 
  616: def manage_addVersionedFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
  617:                    REQUEST=None):
  618:     """Add a new File object.
  619: 
  620:     Creates a new File object 'id' with the contents of 'file'"""
  621: 
  622:     id=str(id)
  623:     title=str(title)
  624:     content_type=str(content_type)
  625:     precondition=str(precondition)
  626:     
  627:     id, title = cookId(id, title, file)
  628: 
  629:     self=self.this()
  630: 
  631:     # First, we create the file without data:
  632:     self._setObject(id, versionedFileObject(id,title,'',content_type, precondition))
  633:     self._getOb(id).versionComment=str(vC)
  634:     self._getOb(id).time=time.localtime()
  635:     
  636:     setattr(self._getOb(id),'author',author)
  637:     
  638:     # Now we "upload" the data.  By doing this in two steps, we
  639:     # can use a database trick to make the upload more efficient.
  640:     if file:
  641:         self._getOb(id).manage_upload(file)
  642:     if content_type:
  643:         self._getOb(id).content_type=content_type
  644: 
  645:     if REQUEST is not None:
  646:         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
  647: 
  648: 
  649: 
  650: 
  651: class versionedFile(CatalogAware,Folder):
  652:     """Versioniertes File"""
  653: 
  654:     default_catalog='fileCatalog'
  655:     
  656:     def PrincipiaSearchSource(self):
  657:            """Return cataloguable key for ourselves."""
  658:            return str(self)
  659:        
  660:     def __init__(self, id, title, lockedBy,author):
  661:         """init"""
  662:         self.id=id
  663:         self.title=title
  664:         self.lockedBy=lockedBy
  665:         self.author=author
  666: 
  667:     def manageImagesForm(self):
  668:         """manage Images attached to the file"""
  669: 
  670:         self.REQUEST.SESSION['refer']=self.REQUEST['HTTP_REFERER']
  671:         
  672:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageImage')).__of__(self)
  673:         return pt()
  674: 
  675:     def manageImages(self,imageUrl=None,caption=None,REQUEST=None):
  676:         """manage URL"""
  677:         if imageUrl and (not imageUrl==""):
  678:             manage_AddImageZogiLib(self,libPath=imageUrl,caption=caption)
  679: 
  680:         if self.REQUEST.SESSION.has_key('refer'):
  681: 
  682:             return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
  683:         return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
  684:     
  685:     
  686:     
  687:     def changeImages(self,caption=None,submit=None,id=None,REQUEST=None):
  688:         """manage URL"""
  689:         if submit=="change caption":
  690:             image=self.ZopeFind(self,obj_ids=[id])
  691:             if image:
  692:                 image[0][1].caption=caption[0:]
  693:         
  694:         elif submit=="delete":
  695:             image=self.ZopeFind(self,obj_ids=[id])
  696:             if image:
  697:                 self.manage_delObjects([image[0][1].getId()])
  698: 
  699: 
  700:         if self.REQUEST.SESSION.has_key('refer'):
  701: 
  702:             return REQUEST.RESPONSE.redirect(self.REQUEST.SESSION['refer'])
  703:         return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
  704:     
  705:         
  706: 
  707: 
  708:     def getImages(self):
  709:         """get Images"""
  710:         images=self.ZopeFind(self,obj_metatypes=["ImageZogiLib"])
  711:         if not images:
  712:             return None
  713:         else:
  714:             return images
  715:                              
  716:         
  717:     def getComment(self):
  718:         """get the comment of this file"""
  719:         if not hasattr(self,'comment') or (not self.comment) or (self.comment.lstrip()==""):
  720:             return "Add comment"
  721: 
  722:         else:
  723:             return self.comment
  724:             
  725:         
  726:     meta_type="versionedFile"
  727: 
  728:     def manageCommentForm(self):
  729:         """add a comment"""
  730:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addComment')).__of__(self)
  731:         return pt()
  732: 
  733:     def manageComment(self,text,comment_author,submit,REQUEST=None):
  734:         """manage comments"""
  735:         if submit =='change':
  736:             if text=='':
  737:                 self.comment=None
  738:             else:
  739:                 self.comment=text
  740:                 self.comment_author=comment_author
  741: 
  742:                 self.comment_date=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
  743: 
  744:         return REQUEST.RESPONSE.redirect(self.aq_parent.absolute_url())
  745:     
  746:     def getLastVersion(self):
  747:         """Last Version"""
  748:         tmp=0
  749:         lastVersion=None
  750:         
  751:         
  752:         for version in self.ZopeFind(self):
  753:             
  754:             if hasattr(version[1],'versionNumber'):
  755:                 
  756:                 if int(version[1].versionNumber) > tmp:
  757:                     tmp=int(version[1].versionNumber,)
  758:                     lastVersion=version[1]
  759:             if lastVersion==None:
  760:                 lastVersion=version[1]
  761:                 lastVersion.versionNumber=1
  762:         return lastVersion
  763:     
  764:     def index_html(self):
  765:         """main view"""
  766:         lastVersion=self.getLastVersion()
  767:         #return "File:"+self.title+"  Version:%i"%lastVersion.versionNumber," modified:",lastVersion.bobobase_modification_time()," size:",lastVersion.getSize(),"modified by:",lastVersion.lastEditor()
  768:         return "File: %s Version:%i modified:%s size:%s modified by:%s"%(self.title,lastVersion.versionNumber,lastVersion.getTime(),lastVersion.getSize(),lastVersion.lastEditor())
  769:     security= ClassSecurityInfo()                           
  770:     security.declarePublic('getVersion')                                              
  771:     def getVersion(self):
  772:         tmp=0
  773:         for version in self.ZopeFind(self):
  774:             
  775:             if hasattr(version[1],'versionNumber'):
  776:                 
  777:                 if int(version[1].versionNumber) > tmp:
  778:                     tmp=int(version[1].versionNumber,)
  779:         return tmp+1
  780: 
  781: 
  782:     security.declareProtected('AUTHENTICATED_USER','unlock')
  783: 
  784:     def history(self):
  785:         """history"""  
  786: 
  787:         ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
  788:         if ext:
  789:             return getattr(self,ext[0][1].getId())()
  790:         
  791:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','versionHistory')).__of__(self)
  792:         return pt()
  793: 
  794:     def getVersions(self):
  795:         """get all versions"""
  796:         ret=[]
  797:         for version in self.ZopeFind(self):
  798:             if hasattr(version[1],'versionNumber'):
  799:                 ret.append((version[1].versionNumber,version[1]))
  800:         ret.sort(sortv)
  801:         return ret
  802: 
  803:     security.declareProtected('AUTHENTICATED_USER','forceunlock')   
  804:     def forceunlock(self,RESPONSE):
  805:         """unlock"""
  806:         self.lockedBy=''
  807: 
  808:     security.declareProtected('AUTHENTICATED_USER','unlock')   
  809:     def unlock(self,RESPONSE):
  810:         """unlock"""
  811:         if str(self.lockedBy) in [str(self.REQUEST['AUTHENTICATED_USER'])]:
  812:             self.lockedBy=''
  813:             RESPONSE.redirect(self.REQUEST['URL2'])
  814:         else:
  815:             return "Sorry, not locked by you! (%s,%s)"%(self.lockedBy,self.REQUEST['AUTHENTICATED_USER'])
  816:         
  817: 
  818:     
  819:     security.declareProtected('AUTHENTICATED_USER','addVersionedFileObjectForm')
  820: 
  821:     def addVersionedFileObjectForm(self):
  822:         """add a new version"""
  823:         
  824:         if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
  825:             return "please login first"
  826:         if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
  827:             out=DTMLFile('dtml/fileAdd', globals(),Kind='VersionedFileObject',kind='versionedFileObject',version=self.getVersion()).__of__(self)
  828:             return out()
  829:         else:
  830:             return "Sorry file is locked by somebody else"
  831:         
  832:     def manage_addVersionedFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
  833:         """add"""
  834:         try: #der ganze vC unsinn muss ueberarbeitet werden
  835:             vC=self.REQUEST['vC']
  836:         except:
  837:             pass
  838:         
  839:         author=self.REQUEST['author']
  840:         
  841:         if changeName=="yes":
  842:             filename=file.filename
  843:             self.title=filename[max(filename.rfind('/'),
  844:                         filename.rfind('\\'),
  845:                         filename.rfind(':'),
  846:                         )+1:]
  847: 
  848: 
  849:         if not newName=='':
  850:             self.title=newName[0:]
  851:         print self.title
  852:         
  853:         id="V%i"%self.getVersion()+"_"+self.title
  854:         
  855:         manage_addVersionedFileObject(self,id,vC,author,file,"V%i"%self.getVersion()+"_"+self.title,precondition, content_type)
  856:         objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
  857:         self.REQUEST.SESSION['objID_parent']=self.getId()
  858: 
  859:         if RESPONSE:
  860:             obj=self.ZopeFind(self,obj_ids=[id])[0][1]
  861:             if obj.getSize()==0:
  862:                 self.REQUEST.SESSION['objID']=obj.getId()
  863:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
  864:                 return pt()
  865: 
  866:             else:
  867:                 RESPONSE.redirect(self.REQUEST['URL2'])
  868: 
  869:         else:
  870:             return self.ZopeFind(self,obj_ids=[id])[0][1]
  871:         
  872:     security.declareProtected('AUTHENTICATED_USER','downloadLocked')
  873: 
  874:     def download(self):
  875:         """download and lock"""
  876: 
  877:         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
  878:         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
  879:       
  880: 	#try:	
  881: 	#	txt=self.getLastVersion.index_html()
  882: 	#except:
  883: 	#	txt=self.getLastVersion.index_html(REQUEST,RESPONSE)
  884: 
  885: 	#self.REQUEST.RESPONSE.setHeader("Content-Length","str(len(txt)+1000)")
  886:       	
  887:         self.content_type="application/octet-stream"
  888:         #self.REQUEST.RESPONSE.write("bl")
  889:         #self.REQUEST.RESPONSE.write(txt)
  890:         #self.REQUEST.close()
  891: 
  892:         #self.getLastVersion().content_type="application/octet-stream"
  893:         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
  894:     
  895:     def downloadLocked(self):
  896:         """download and lock"""
  897:         if self.REQUEST['AUTHENTICATED_USER']=='Anonymous User':
  898:             return "please login first"
  899:         if not self.lockedBy=="":
  900:             return "cannot be locked because is already locked by %s"%self.lockedBy
  901:         self.lockedBy=self.REQUEST['AUTHENTICATED_USER']
  902:         self.getLastVersion().content_type="application/octet-stream"
  903:         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+'/'+self.getId()+'/'+self.getLastVersion().getId())
  904:     
  905: def manage_addVersionedFileForm(self):
  906:     """interface for adding the OSAS_root"""
  907:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addVersionedFile.zpt')).__of__(self)
  908:     return pt()
  909: 
  910: def manage_addVersionedFile(self,id,title,lockedBy, author=None, RESPONSE=None):
  911:     """add the OSAS_root"""
  912:     newObj=versionedFile(id,title,lockedBy,author)
  913:     self._setObject(id,newObj)
  914:    
  915:     if RESPONSE is not None:
  916:         RESPONSE.redirect('manage_main')
  917: 
  918: 
  919: InitializeClass(versionedFile)
  920: InitializeClass(versionedFileFolder)

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