File:  [Repository] / cdli / cdli_files.py
Revision 1.10: download - view: text, annotated - select for diffs - revision graph
Wed Mar 15 14:57:37 2006 UTC (18 years, 3 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
minor

    1: """CDLI extensions of the filearchive"""
    2: from Products.versionedFile.versionedFile import *
    3: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
    4: from tempfile import mkstemp,mkdtemp
    5: import os.path
    6: import os
    7: from types import *
    8: import urlparse
    9: from OFS.OrderedFolder import OrderedFolder
   10: from OFS.SimpleItem import SimpleItem
   11: import time
   12: 
   13: 
   14: 
   15: class Basket_old(Folder):
   16:     """shopping basket - alte fassung """
   17:     
   18:     meta_type="Basket"
   19:     _v_stack={}
   20: 
   21:     def getObjUrl(self,objId):
   22:         """getUrl"""
   23:         founds=self.CDLICatalog.search({'title':objId})
   24:         if len(founds)>0:
   25:              return founds[0].getObject().absolute_url()
   26:          
   27:         else: #assume version number
   28:             splitted=objId.split("_")
   29:             founds=self.CDLICatalog.search({'title':splitted[1]})        
   30:             return founds[0].getObject().absolute_url()+'/'+objId
   31:         
   32:     def storeAllLink(self,results):
   33:         """erzeuge link zum speicher aller results"""
   34:         nr=self.REQUEST['_ZopeId']
   35:         
   36:         if results:
   37:             self._v_stack[nr]=[x.getObject().getId() for x in results]
   38:         
   39:         return self.absolute_url()+"/storeAll?id="+nr
   40:     
   41:     def storeAll(self,id):
   42:         """store all"""
   43:         try:
   44:             results=self._v_stack[id]
   45:         except:
   46:             #TODO: write expired page
   47:             return "expired"
   48:         
   49:         return self.storeInBasketForm(results)
   50:         
   51:     def storeInBasketForm(self,ids):
   52:         """ store an object form"""
   53:         
   54:         if type(ids) is not ListType:
   55:             ids=[ids]
   56:         self.REQUEST.SESSION['ids']=ids[0:]
   57:         
   58:         self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']
   59: 
   60:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)
   61:         return pt()
   62:         
   63:     def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):
   64:         """store it"""
   65:         
   66:         if not ids:
   67:             ids=REQUEST.SESSION['ids']
   68:             
   69:         self.REQUEST.SESSION['basketUser']=username
   70:         
   71:         baskets=self.ZopeFind(self,obj_ids=[username])
   72:         if len(baskets)>0:
   73:             basket=baskets[0][1]
   74:         else:
   75:             manage_addBasketObject(self,username)
   76:             basket=self._getOb(username)
   77:         
   78:         
   79:         basket.addObjects(ids)
   80:         back=self.REQUEST.SESSION.get('BACKLINK', None)
   81: 
   82:         if RESPONSE:
   83:             RESPONSE.redirect(back)
   84:             
   85: 
   86:     
   87:     def showBasket(self,user=None,set=None,RESPONSE=None):
   88:         """show the basket"""
   89:         
   90:         if user:
   91:             self.REQUEST.SESSION['basketUser']=user
   92:         
   93:         if not user and not set:
   94:             user=self.REQUEST.SESSION.get('basketUser',None)
   95:         
   96:         if not user:
   97:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)
   98:             return pt()
   99:         else:
  100:             baskets=self.ZopeFind(self,obj_ids=[user])
  101:         
  102: 
  103:         if len(baskets)>0:
  104:             RESPONSE.redirect(baskets[0][1].absolute_url())
  105:             return True 
  106:         else:
  107:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)
  108:             return pt()
  109:         
  110: 
  111: def manage_addBasket_oldForm(self):
  112:     """add the basket form"""
  113:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
  114:     return pt()
  115: 
  116: def manage_addBasket_old(self,id,title,RESPONSE=None):
  117:     """add the basket"""
  118:     ob=Basket()
  119:     
  120:     ob.id=str(id)
  121:     ob.title=title
  122:     self._setObject(id, ob)
  123:     ob=self._getOb(id)
  124:     
  125:     if RESPONSE is not None:
  126:         RESPONSE.redirect('manage_main')
  127: 
  128:     
  129: class BasketObject_old(Folder):
  130:     """Basket Object - alte fassung"""
  131:     
  132:     meta_type="basketObject"
  133:     def __init__(self):
  134:         	"""init basket object"""
  135:         	self.contents=[]
  136: 
  137:     def numberOfItems(self):
  138:         """return anzahl der elemente im basket"""
  139:         return len(self.contents)
  140:     
  141:     def addObjects(self,ids):
  142:         """addObjects"""
  143:         
  144:         for id in ids:
  145:             founds=self.CDLICatalog.search({'title':id})
  146:             for found in founds:
  147:                 if found.getObject() not in self.contents:
  148:                     tm=self.contents[0:]
  149:                     tm.append(found.getObject())
  150:                     self.contents=tm[0:]
  151:     
  152:         return True
  153: 
  154:     def index_html(self):
  155:         	"""view the basket"""
  156:         	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
  157:         	return pt()
  158: 
  159:     def deleteObjects(self,ids,RESPONSE=None):
  160:         """delete objects"""
  161:         list = self.contents[0:]
  162:         for content in list:
  163:                
  164:                 if content.getId() in ids:
  165:                     self.contents.remove(content)
  166:         
  167: 
  168:         if RESPONSE:
  169:         	    RESPONSE.redirect(self.absolute_url())
  170: 
  171: 
  172:     def unlockTest(self):
  173:         """unlock all files of the testuser for debuggin"""
  174:         for object in self.contents:
  175: 
  176:                 if str(object.lockedBy)=="test":
  177:                     object.lockedBy=""
  178:             
  179:     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
  180:         """download all selected files in one file"""
  181:         
  182:         ret=""
  183:         lockedObjects={}
  184:         
  185: 
  186:         if lock:
  187:             
  188:             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
  189:                 
  190:                 return "please login first"
  191: 
  192:             #check if a locked object exist in the basket.
  193:             lockedObjects={}
  194:             for object in self.contents:
  195: 
  196:                 if not object.lockedBy=="":
  197:                     lockedObjects[object.title]=repr(object.lockedBy)
  198:                    
  199:                     
  200:             keys=lockedObjects.keys()
  201:             
  202:             
  203:             if len(keys)>0 and (not procedure):
  204:                 self.REQUEST.SESSION['lockedObjects']=lockedObjects
  205:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
  206:                 return pt()
  207:          
  208:             elif not procedure: #keine fails gesperrt dann alle donwloaden
  209:                 procedure="downloadAll" 
  210:         
  211:         print procedure    
  212:         for object in self.contents:
  213:             
  214:                 if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
  215:                     ret+=object.getLastVersion().data
  216:                 
  217:                 if lock and object.lockedBy=='':
  218:                     object.lockedBy=self.REQUEST['AUTHENTICATED_USER']
  219: 
  220: 
  221:         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())
  222:         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
  223:         length=len(ret)
  224:         self.REQUEST.RESPONSE.setHeader("Content-Length",length)
  225:         self.REQUEST.RESPONSE.write(ret)    
  226:         
  227:         
  228: def manage_addBasket_oldObjectForm(self):
  229:     """add form"""
  230:     pass
  231: 
  232: def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):
  233:     """add"""
  234:     
  235:     ob=BasketObject()
  236:     
  237:     ob.id=str(id)
  238:     ob.title=title
  239:     self._setObject(id, ob)
  240:     ob=self._getOb(id)
  241:     
  242:     if RESPONSE is not None:
  243:         RESPONSE.redirect('manage_main')
  244: 
  245: 
  246: class CDLIBasketContainer(OrderedFolder):
  247:     """contains the baskets"""
  248:     
  249: 
  250:     security=ClassSecurityInfo()
  251:     meta_type="CDLIBasketContainer"
  252:     
  253:     
  254:     def getBasketIdfromName(self,basketname):
  255:         """get id from name"""
  256: 
  257:         for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):
  258:             if basket[1].title==basketname:
  259:                 return basket[0]
  260:         else:
  261:             None
  262:     
  263:     security.declareProtected('manage','uploadBasket_html')        
  264:             
  265:     def uploadBasket_html(self,basketId='0'):
  266:         """upload an atf file, html form"""
  267:         
  268: 
  269:         basketId=str(basketId)
  270:         if not basketId=='0':
  271:             basketName=getattr(self.basketContainer,basketId).title
  272:         else:
  273:             basketName=""
  274:             
  275:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)
  276:         return pt(basketId=basketId,basketName=basketName)
  277:    
  278: 
  279:         
  280:     def index_html(self):
  281:         """stanadard ansicht"""
  282:         
  283: 
  284: 
  285:         ext=self.ZopeFind(self,obj_ids=["index.html"])
  286:         if ext:
  287:             return ext[0][1]()
  288:         
  289:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)
  290:         return pt()
  291:     
  292:     def getStorageFolderRoot(self):
  293:         """root des storage folders"""
  294:         return self.cdli_main
  295:     
  296:     def __init__(self,id,title):
  297:         """ init basket container"""
  298:         self.id=id
  299:         self.title=title
  300:      
  301:      
  302:     def getBaskets(self,sortField='title'):
  303:         """get all baskets files"""
  304: 
  305:         def sortName(x,y):
  306:             return cmp(x[1].title.lower(),y[1].title.lower())
  307: 
  308:         def sortDate(x,y):
  309:             return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
  310: 
  311:         
  312:         def sortComment(x,y):
  313: 
  314:         
  315:             
  316:              try:
  317:                 xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
  318:              except:
  319:                 xc='ZZZZZZZZZZZZZ'.lower()
  320:              try:
  321:                 yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
  322:              except:
  323:                 yc='ZZZZZZZZZZZZZ'.lower()
  324:     
  325:     
  326:              if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
  327:                  
  328:                  try:
  329:                      xc=x[1].getLastVersion().getComment().lower()
  330:                  except:
  331:                      xc='ZZZZZZZZZZZZZ'.lower()
  332:                      
  333:              if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
  334:                  try:
  335:                      yc=y[1].getLastVersion().getComment().lower()
  336:                  except:
  337:                      yc='ZZZZZZZZZZZZZ'.lower()
  338:     
  339:              
  340:                  return cmp(xc,yc)
  341:         
  342:         def sortAuthor(x,y):
  343:             
  344:             return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())
  345:         
  346:         baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
  347:         
  348:         
  349:         if sortField=='title':
  350:             baskets.sort(sortName)
  351:         elif sortField=='date':
  352:             baskets.sort(sortDate)
  353:         elif sortField=='author':
  354:             baskets.sort(sortAuthor)
  355:         elif sortField=='comment':
  356:             baskets.sort(sortComment)
  357: 
  358:         return baskets
  359: 
  360: 
  361:                        
  362:     def getNewId(self):
  363:         """createIds"""
  364:         last=getattr(self,'last',0)
  365:         last +=1
  366:         while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
  367:             last+=1
  368:     
  369:         self.last=last
  370:         return last
  371:     
  372:     def setActiveBasket(self,basketId,REQUEST=None):
  373:         """store active basketId in a cookie"""
  374:         self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
  375:         if REQUEST:
  376:             REQUEST.RESPONSE.redirect(REQUEST['URL1'])
  377:             
  378:     def getActiveBasket(self):
  379:         """get active basket from cookie"""
  380:         
  381:         id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
  382:         if id:
  383:             obj=getattr(self,str(id),None)
  384:         else:
  385:             obj=None
  386:         return obj
  387:     
  388:     def getActualUserName(self):
  389:         """get name of the actualuser"""
  390:         return str(self.REQUEST['AUTHENTICATED_USER'])
  391:     
  392:     
  393:     def addBasket(self,newBasketName):
  394:         """add a new basket"""
  395:         
  396:         ob=manage_addCDLIBasket(self,newBasketName)
  397:         return ob
  398:     
  399:     def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):
  400:         """store it"""
  401:         if not ids:
  402:             ids=self.REQUEST.SESSION['fileIds']
  403:             
  404:         if type(ids) is not ListType:
  405:             ids=[ids]
  406:         
  407:         if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
  408:             basketRet=self.addBasket(newBasketName)
  409:             self.setActiveBasket(basketRet.getId())
  410:             basket=getattr(self,basketRet.getId())
  411:         elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):
  412:             basket=self.getActiveBasket()
  413:         
  414:         added=basket.addObjects(ids)
  415:         back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)
  416:         
  417:         
  418:         if fromFileList:
  419: 
  420:             return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)
  421:        
  422:         if RESPONSE:
  423:             
  424:             RESPONSE.redirect(back)
  425:             
  426:         return True
  427:     
  428: def manage_addCDLIBasketContainerForm(self):
  429:     """add the CDLIBasketContainer form"""
  430:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)
  431:     return pt()
  432: 
  433: def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):
  434:     """add the basket"""
  435:     ob=CDLIBasketContainer(id,title)
  436:     
  437:     self._setObject(id, ob)
  438:     
  439:     if RESPONSE is not None:
  440:         RESPONSE.redirect('manage_main')
  441: 
  442: class CDLIBasket(Folder,CatalogAware):
  443:     """basket"""
  444:     
  445:     meta_type="CDLIBasket"
  446:     default_catalog="CDLIBasketCatalog"
  447:     
  448:     def getFile(self,obj):
  449:         return obj[1]
  450:     
  451:     def getFileLastVersion(self,obj):
  452:         return obj[0]
  453:     
  454:     def getFileNamesInLastVersion(self):
  455:         """get content of the last version as list"""
  456:         
  457:         return [x[1].getId() for x in self.getLastVersion().getContent()]
  458:     
  459:     def isActual(self,obj):
  460:         """teste ob im basket die aktuelle version ist"""
  461:         actualNo=obj[1].getLastVersion().getVersionNumber()
  462:         storedNo=obj[0].getVersionNumber()
  463:         if actualNo==storedNo:
  464:             return True
  465:         else:
  466:             return False
  467:         
  468:     def history(self):
  469:         """history"""  
  470: 
  471:         ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
  472:         if ext:
  473:             return getattr(self,ext[0][1].getId())()
  474:         
  475:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self)
  476:         return pt()
  477:     
  478:     def getStorageFolderRoot(self):
  479:         """root des storage folders"""
  480:         return self.aq_parent.cdli_main
  481:     
  482:     def __init__(self,id,title,shortDescription="",comment=""):
  483:         """init a CDLIBasket"""
  484:         
  485:         self.id=id
  486:         self.title=title
  487:         self.shortDescription=shortDescription
  488:         self.comment=comment
  489:  
  490:    
  491:            
  492:     def getLastVersion(self):
  493:         """hole letzte version"""
  494:         ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])]
  495:         ids.sort()
  496:         if len(ids)==0:
  497:             return None
  498:         else:    
  499:             ob=getattr(self,str(ids[-1]))
  500:             return ob
  501:    
  502:     def getVersions(self):
  503:         """get versions"""
  504:         versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])
  505:         return versions
  506: 
  507:    
  508:     
  509:     def addObjects(self,ids,deleteOld=None):
  510:         """generate a new version of the basket with objects added"""
  511:        
  512:         lastVersion=self.getLastVersion()
  513:         
  514:         if lastVersion is None:
  515:             oldContent=[]
  516:         else:
  517:             oldContent=lastVersion.basketContent[0:]
  518: 
  519:         if deleteOld:
  520:             oldContent=[]
  521: 
  522:         newContent=[]
  523:         added=0
  524:         for id in ids:
  525:             founds=self.CDLICatalog.search({'title':id})
  526: 
  527:             for found in founds:
  528:                 if found.getObject() not in oldContent:
  529:                     #TODO: was passiert wenn, man eine Object dazufŸgt, das schon da ist aber eine neuere version
  530:                     newContent.append((found.getObject().getLastVersion(),found.getObject()))
  531:                     added+=1
  532: 
  533:         content=oldContent+newContent
  534:         
  535:         user=self.getActualUserName()
  536:         
  537:         ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
  538:     
  539:         return added
  540:     
  541:     def deleteObjects(self,ids,RESPONSE=None):
  542:         """delete objects"""
  543:         #TODO: implement delete Objects
  544:         
  545: def manage_addCDLIBasketForm(self):
  546:     """add the CDLIBasketContainer form"""
  547:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)
  548:     return pt()
  549: 
  550: def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):
  551:     """add the basket"""
  552:     
  553:     id=str(self.getNewId())
  554:     
  555:     ob=CDLIBasket(id,title,shortDescription,comment)
  556:     
  557:     self._setObject(id, ob)
  558:     
  559:     if RESPONSE is not None:
  560:         RESPONSE.redirect('manage_main')
  561:     else:
  562:         return ob
  563: 
  564: class CDLIBasketVersion(SimpleItem):
  565:     """version of a basket"""
  566:     
  567:     meta_type="CDLIBasketVersion"
  568:     
  569:     def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
  570:         """download all selected files in one file"""
  571:         
  572:         ret=""
  573:         lockedObjects={}
  574:         
  575: 
  576:         if lock:
  577:             
  578:             if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
  579:                 
  580:                 return "please login first"
  581: 
  582:             #check if a locked object exist in the basket.
  583:             lockedObjects={}
  584:             for object in self.basketContent:
  585: 
  586:                 if not object[1].lockedBy=="":
  587:                     lockedObjects[object[1].title]=repr(object[1].lockedBy)
  588:                    
  589:                     
  590:             keys=lockedObjects.keys()
  591:             
  592:             
  593:             if len(keys)>0 and (not procedure):
  594:                 self.REQUEST.SESSION['lockedObjects']=lockedObjects
  595:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
  596:                 return pt()
  597:          
  598:             elif not procedure: #keine fails gesperrt dann alle donwloaden
  599:                 procedure="downloadAll" 
  600:         
  601: 
  602:         for object in self.basketContent:
  603:             
  604:                 if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):
  605:                     ret+=object[0].data
  606:                 
  607:                 if lock and object[1].lockedBy=='':
  608:                     object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
  609: 
  610:         basket_name=self.aq_parent.title+"_V"+self.getId()
  611:         
  612:         #write basketname to header of atf file
  613:         ret="#atf basket %s\n"%basket_name+ret
  614:         
  615:         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
  616:         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
  617:         length=len(ret)
  618:         self.REQUEST.RESPONSE.setHeader("Content-Length",length)
  619:         self.REQUEST.RESPONSE.write(ret)    
  620:         
  621:  
  622:     def numberOfItems(self):
  623:         """return anzahl der elemente im basket"""
  624:         return len(self.basketContent)
  625:     
  626:     def getTime(self):
  627:         """getTime"""
  628:         #return self.bobobase_modification_time().ISO()
  629:       
  630:         if hasattr(self,'time'):
  631:             return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
  632:         elif hasattr(self,'timefixed'):
  633:             return self.timefixed
  634:         else:
  635:             setattr(self,'timefixed',self.bobobase_modification_time().ISO())
  636:             return self.bobobase_modification_time().ISO()
  637:     
  638:     def getContent(self):
  639:         """get Basket Content"""
  640:         return self.basketContent
  641: 
  642:     
  643:     def __init__(self,id,user,comment="",basketContent=[]):
  644:         """ init a basket version"""
  645:         self.id=id
  646:         self.coment=comment
  647:         self.basketContent=basketContent[0:]
  648:         self.user=user
  649:         self.time=time.localtime()
  650:         
  651:     def getUser(self):
  652:         """get user"""
  653:         return self.user
  654:     
  655:     def getComment(self):
  656:         """get Comment"""
  657:         return self.comment
  658:  
  659:     def index_html(self):
  660:             """view the basket"""
  661:             pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
  662:             return pt()
  663:      
  664:     def getObjUrl(self,result):
  665:         """getUrl of the version of the object"""
  666:         objId=result[1].getTitle()
  667:         founds=self.CDLICatalog.search({'title':objId})
  668:         if len(founds)>0:
  669:              return founds[0].getObject().absolute_url()
  670:          
  671:         else: #assume version number
  672:             splitted=objId.split("_")
  673:             founds=self.CDLICatalog.search({'title':splitted[1]})        
  674:             return founds[0].getObject().absolute_url()+'/'+objId
  675:    
  676: def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
  677:     """add a version"""
  678:     
  679:     #check for already existing versions
  680:  
  681:     lastVersion=self.getLastVersion()
  682:     if lastVersion is None:
  683:         newId=str(1)
  684:     else:
  685:         newId=str(int(lastVersion.getId())+1)
  686:     
  687:     ob=CDLIBasketVersion(newId,user,comment,basketContent)
  688:     
  689:     self._setObject(newId, ob)
  690:     
  691:     if RESPONSE is not None:
  692:         RESPONSE.redirect('manage_main')
  693:     else:
  694:         return ob
  695:     
  696: class CDLIFileObject(versionedFileObject):
  697:     """CDLI file object"""
  698:     
  699:     meta_type="CDLI File Object"
  700:     
  701:         
  702:     def view(self):
  703:         """view file"""
  704:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
  705:         return pt()
  706:     
  707: manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')
  708: 
  709: def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
  710:                    REQUEST=None):
  711:     """Add a new File object.
  712: 
  713:     Creates a new File object 'id' with the contents of 'file'"""
  714: 
  715:     id=str(id)
  716:     title=str(title)
  717:     content_type=str(content_type)
  718:     precondition=str(precondition)
  719:     
  720:     id, title = cookId(id, title, file)
  721: 
  722:     self=self.this()
  723: 
  724:     # First, we create the file without data:
  725:     self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))
  726:     self._getOb(id).versionComment=str(vC)
  727:     self._getOb(id).time=time.localtime()
  728:     
  729:     setattr(self._getOb(id),'author',author)
  730:     
  731:     # Now we "upload" the data.  By doing this in two steps, we
  732:     # can use a database trick to make the upload more efficient.
  733:     if file:
  734:         self._getOb(id).manage_upload(file)
  735:     if content_type:
  736:         self._getOb(id).content_type=content_type
  737: 
  738:     if REQUEST is not None:
  739:         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
  740:     
  741: class CDLIFile(versionedFile,CatalogAware):
  742:     """CDLI file"""
  743:     
  744:     meta_type="CDLI file"
  745:     default_catalog='CDLICatalog'
  746:     
  747:     
  748:     
  749:     def isContainedInBaskets(self,context=None):
  750:         """check is this file is part of any basket
  751:         @param context: (optional) necessessary if CDLIBasketCatalog is not an (inherited) attribute of self, context.CDLIBasketCatalog
  752:                         has to exist.
  753:         """
  754: 
  755:         if not context:
  756:             context=self
  757:             
  758:         return [x.getObject() for x in context.CDLIBasketCatalog.search({'getFileNamesInLastVersion':self.getId()})]
  759:         
  760:         
  761:     def addCDLIFileObjectForm(self):
  762:         """add a new version"""
  763:         
  764:         if str(self.REQUEST['AUTHENTICATED_USER']) in ["Anonymous User"]:
  765:             return "please login first"
  766:         if (self.lockedBy==self.REQUEST['AUTHENTICATED_USER']) or (self.lockedBy==''):
  767:             out=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject',version=self.getVersion()).__of__(self)
  768:             return out()
  769:         else:
  770:             return "Sorry file is locked by somebody else"
  771:         
  772:     def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):
  773:         """add"""
  774:         try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
  775:             vC=self.REQUEST['vC']
  776:         except:
  777:             pass
  778:         
  779:         author=self.REQUEST.SESSION['author']
  780:         
  781:         if changeName=="yes":
  782:             filename=file.filename
  783:             self.title=filename[max(filename.rfind('/'),
  784:                         filename.rfind('\\'),
  785:                         filename.rfind(':'),
  786:                         )+1:]
  787: 
  788: 
  789:         if not newName=='':
  790:             self.title=newName[0:]
  791:         
  792:         
  793: 
  794:         
  795:         
  796:         positionVersionNum=getattr(self,'positionVersionNum','front')
  797:         
  798:         if positionVersionNum=='front':
  799:             id="V%i"%self.getVersion()+"_"+self.title
  800:         else:
  801:             tmp=os.path.splitext(self.title)
  802:             if len(tmp)>1:
  803:                 id=tmp[0]+"_V%i"%self.getVersion()+tmp[1]
  804:             else:
  805:                 id=tmp[0]+"_V%i"%self.getVersion()
  806:             
  807:         
  808:         manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)
  809:         objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
  810:         self.REQUEST.SESSION['objID_parent']=self.getId()
  811: 
  812:         if RESPONSE:
  813:             obj=self.ZopeFind(self,obj_ids=[id])[0][1]
  814:             if obj.getSize()==0:
  815:                 self.REQUEST.SESSION['objID']=obj.getId()
  816:                 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','errorUploadFile')).__of__(self)
  817:                 return pt()
  818: 
  819:             else:
  820:                 RESPONSE.redirect(self.REQUEST['URL2'])
  821: 
  822:         else:
  823:             return self.ZopeFind(self,obj_ids=[id])[0][1]
  824:         
  825:         
  826: def manage_addCDLIFileForm(self):
  827:     """interface for adding the OSAS_root"""
  828:     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIFile.zpt')).__of__(self)
  829:     return pt()
  830: 
  831: def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
  832:     """add the OSAS_root"""
  833:     newObj=CDLIFile(id,title,lockedBy,author)
  834:     self._setObject(id,newObj)
  835:    
  836:     if RESPONSE is not None:
  837:         RESPONSE.redirect('manage_main')
  838: 
  839: 
  840: 
  841: 
  842: def splitatf(fh,dir=None):
  843:     """split it"""
  844:     ret=None
  845:     nf=None
  846:     for line in fh.readlines():
  847:         #check if basket name is in the first line
  848:         if line.find("#atf basket")>=0:
  849:             ret=line.replace('#atf basket ','')
  850:             ret=ret.split('_')[0]
  851:         else:
  852:             if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
  853:                 if nf:
  854:                     nf.close() #close last file
  855:             
  856:                 
  857:                 filename=line[1:].split("=")[0].rstrip()+".atf"
  858:                 if dir:
  859:                     filename=os.path.join(dir,filename)
  860:                 nf=file(filename,"w")
  861:             if nf:    
  862:                 nf.write(line)
  863:         
  864:     nf.close()
  865:     fh.close()
  866:     return ret,len(os.listdir(dir))
  867: 
  868: class CDLIFileFolder(versionedFileFolder):
  869:     """CDLI File Folder"""
  870:     
  871:     meta_type="CDLI Folder"
  872:     filesMetaType=['CDLI file']
  873:     folderMetaType=['CDLI Folder']
  874:     default_catalog='CDLICatalog'
  875:     
  876:     def getVersionNumbersFromIds(self,ids):
  877:         """get the numbers of the current versions of documents described by their ids"""
  878:         
  879:         ret=[]
  880:         searchStr=" OR ".join(ids)
  881:         
  882:         founds=self.CDLICatalog.search({'title':searchStr})
  883:         
  884:         for found in founds:
  885:             lastVersion=found.getObject().getLastVersion()
  886:             ret.append((found.getId,lastVersion))
  887:         
  888:         return ret
  889:     
  890:  
  891:     def uploadATF(self,upload,basketId=0,RESPONSE=None):
  892:         """upload an atf file"""
  893:         #TODO: add comments
  894:         #TODO: finish uploadATF
  895:         basketId=str(basketId)
  896:         
  897:         
  898:         
  899:         dir=mkdtemp()
  900:         changed=[]
  901:         errors=[]
  902:         newPs=[]
  903:         basketNameFromFile, numberOfFiles=splitatf(upload,dir)
  904:         
  905:         if basketId == '0':
  906:             basketObj=self.basketContainer.getActiveBasket()
  907:             if basketObj:
  908:                 basketId=basketObj.getId()
  909:                 
  910:         if basketId == '0':
  911:             basketNameFromId=""
  912:             basketLen=0
  913:         else:
  914:             basketNameFromId=getattr(self.basketContainer,basketId).title
  915:             basketLen=getattr(self.basketContainer,basketId).getLastVersion().numberOfItems()
  916:             
  917:             
  918:         for fn in os.listdir(dir):
  919:             founds=self.CDLICatalog.search({'title':fn})    
  920:       
  921:             if len(founds)==0:
  922:                 newPs.append(fn)
  923:                 
  924:             for found in founds:
  925:                 obj=found.getObject()
  926:        
  927:                 if (not obj.lockedBy=='') and (not obj.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
  928:                     errors.append(obj)
  929:                 else:
  930:                     data=file(os.path.join(dir,fn)).read()
  931:                     diffs=obj.diff(data)
  932:                     if diffs[0]>0:
  933:                         changed.append((obj,diffs))
  934:                         #hochladen
  935:         
  936:         self.REQUEST.SESSION['changed']=[x[0].getId() for x in changed]
  937:         self.REQUEST.SESSION['errors']=[x.getId() for x in errors]
  938:         self.REQUEST.SESSION['newPs']=newPs
  939:         self.REQUEST.SESSION['tmpdir']=dir
  940:       
  941:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
  942:         return pt(changed=changed,errors=errors,dir=dir,newPs=newPs,basketLen=basketLen,numberOfFiles=numberOfFiles,
  943:                    basketNameFromId=basketNameFromId,basketNameFromFile=basketNameFromFile,basketId=basketId)
  944:                     
  945:     def uploadATFfinally(self,procedure,comment="",basketname='',unlock=None,RESPONSE=None):
  946:         """upload the files"""
  947:         
  948:         if procedure=="uploadchanged":
  949:             uploadFns=self.REQUEST.SESSION['changed']+self.REQUEST.SESSION['newPs']
  950:         
  951:         elif procedure=="uploadAll":
  952:             uploadFns=[]
  953:             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):
  954:                 if not x in self.REQUEST.SESSION['errors']:
  955:                     uploadFns.append(x)
  956:         else:
  957:             uploadFns=[]
  958:             
  959:         for fn in uploadFns:
  960:             founds=self.CDLICatalog.search({'title':fn})
  961:             if len(founds)>0:
  962:                 self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])
  963: 
  964:                 founds[0].getObject().manage_addCDLIFileObject('',comment,self.REQUEST.SESSION['author'],file=file(os.path.join(self.REQUEST.SESSION['tmpdir'],fn)))
  965:             
  966:         
  967:                 
  968:         newPs=self.REQUEST.SESSION['newPs']
  969:         if len(newPs)>0:
  970:             tmpDir=self.REQUEST.SESSION['tmpdir']
  971:         
  972:             self.cdli_main.importFiles(comment=comment,author=str(self.REQUEST['AUTHENTICATED_USER']) ,folderName=tmpDir, files=newPs)
  973:                 
  974:         
  975:         
  976:         #unlock
  977:         if unlock:
  978:             unlockFns=[]
  979:             for x in os.listdir(self.REQUEST.SESSION['tmpdir']):
  980:                     if not x in self.REQUEST.SESSION['errors']:
  981:                         unlockFns.append(x)
  982:             
  983:             for fn in unlockFns:
  984:                 founds=self.CDLICatalog.search({'title':fn})
  985:                 if len(founds)>0:
  986:                     self.REQUEST.SESSION['author']=str(self.REQUEST['AUTHENTICATED_USER'])
  987:                    
  988:                     founds[0].getObject().lockedBy=""
  989:                     
  990:         if not (basketname ==''):
  991:             basketId=self.basketFolder.getBasketIdfromName(basketname)
  992:             
  993:             if not basketId: # create new basket
  994:                 ob=self.basketContainer.addBasket(basketname)
  995:                 basketId=ob.getId()
  996:             basket=getattr(self.basketFolder,str(basketId))
  997:             ids=os.listdir(self.REQUEST.SESSION['tmpdir'])
  998:             basket.addObjects(ids,deleteOld=True)    
  999:                 
 1000:         if RESPONSE is not None:
 1001:             RESPONSE.redirect(self.aq_parent.absolute_url())
 1002:         
 1003: 
 1004:     def findObjectsFromList(self,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
 1005:         """findObjectsFromList (, TAB oder LINE separated)"""
 1006:         if upload: # list from file upload
 1007:             txt=upload.read()
 1008:             txt=txt.replace(",","\n")
 1009:             txt=txt.replace("\t","\n")
 1010:             idsTmp=txt.split("\n")
 1011:             ids=[]
 1012:             for id in idsTmp: # make sure that no empty lines
 1013:                 idTmp=id.lstrip().rstrip()
 1014:                 if len(idTmp)>0:
 1015:                     
 1016:                     ids.append(idTmp)
 1017:                     
 1018:             #self.REQUEST.SESSION['ids']=" OR ".join(ids)
 1019:             
 1020:             pt=getattr(self,'filelist.html')
 1021:             self.REQUEST.SESSION['searchList']=ids
 1022:             return pt(search=ids)
 1023:         
 1024:         if basketName:
 1025:             #TODO: get rid of one of these..
 1026:             
 1027:             pt=getattr(self,'filelist.html')
 1028:             return pt(basketName=basketName,numberOfObjects=numberOfObjects)
 1029:         
 1030:         if list: # got already a list
 1031:             ret=[]
 1032:             for fileId in list:
 1033:                 if len(fileId.split("."))==1:
 1034:                         fileId=fileId+".atf"
 1035:                         
 1036:                 ret+=self.CDLICatalog({'title':fileId})
 1037:             #TODO: get rid of one of these..
 1038:             self.REQUEST.SESSION['fileIds']=[x.getObject().getId() for x in ret]#store fieldIds in session for further usage
 1039:             self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
 1040:             return ret
 1041:         
 1042:         if start:
 1043:             RESPONSE.redirect("filelist.html?start:int="+str(start))
 1044:     
 1045:     def createAllFilesAsSingleFile(self,RESPONSE=None):
 1046:         """download all files"""
 1047:         
 1048:         def sortF(x,y):
 1049:             return cmp(x[0],y[0])
 1050:         
 1051:         catalog=getattr(self,self.default_catalog)
 1052:         #tf,tfilename=mkstemp()
 1053:         
 1054:         
 1055:         list=[(x.getId,x) for x in catalog()]
 1056:         list.sort(sortF)
 1057:         
 1058:         RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
 1059:         RESPONSE.setHeader("Content-Type","application/octet-stream")
 1060:        
 1061:         for l in list:
 1062:             obj=l[1].getObject()
 1063:             
 1064:             if obj.meta_type=="CDLI file":
 1065:                 
 1066:                 #os.write(tf,obj.getLastVersion().data)
 1067:                 if RESPONSE:
 1068:                     RESPONSE.write(obj.getLastVersion().data)
 1069:         #os.close(tf)
 1070:         #RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
 1071:         return True
 1072:     
 1073:     def downloadFile(self,fn):
 1074:         """download fn - not used yet"""
 1075:         self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%self.getLastVersion().getId())
 1076:         self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
 1077:         self.REQUEST.RESPONSE.write(file(fn).read())
 1078:         
 1079:       
 1080:                 
 1081:     def hasParent(self):
 1082:         """returns true falls subfolder"""
 1083:       
 1084:         if self.aq_parent.meta_type in self.folderMetaType:
 1085:             return True
 1086:         else:
 1087:             return False
 1088:         
 1089:     def getFolders(self):
 1090:         """get all subfolders"""
 1091:         ret=[]
 1092:         folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
 1093:         for folder in folders:
 1094:             ret.append((folder[1],
 1095:                         len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
 1096:                         len(self.ZopeFind(folder[1],obj_metatypes=self.filesMetaType))
 1097:                         ))
 1098:         return ret
 1099:     
 1100:             
 1101:     def getFolders_OLD(self):
 1102:         """get all subfolders"""
 1103:         ret=[]
 1104:         folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
 1105:         for folder in folders:
 1106:             ret.append((folder[1],
 1107:                         len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
 1108:                         len(getattr(self,self.default_catalog)({'path':folder[0]}))
 1109:                         ))
 1110:         return ret
 1111:     
 1112:     def index_html(self):
 1113:         """main"""
 1114:         ext=self.ZopeFind(self,obj_ids=["index.html"])
 1115:         if ext:
 1116:             return ext[0][1]()
 1117:         
 1118:         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
 1119:         return pt()
 1120:     
 1121:     def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None):
 1122:         """import files"""
 1123:         
 1124:         if not files:
 1125:             files=os.listdir(folderName)
 1126:             
 1127:         for f in files:
 1128:             folder=f[0:3]
 1129:             f2=f[0:5]
 1130:             obj=self.ZopeFind(self,obj_ids=[folder])
 1131:             
 1132:             if not obj:
 1133:                 manage_addCDLIFileFolder(self,folder,folder)
 1134:                 fobj=getattr(self,folder)
 1135:         
 1136:             else:
 1137:                 fobj=obj[0][1]
 1138:             
 1139:             obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
 1140:         
 1141:             if not obj2:
 1142:                 manage_addCDLIFileFolder(fobj,f2,f2)
 1143:                 fobj2=getattr(fobj,f2)
 1144:         
 1145:             else:
 1146:                 fobj2=obj2[0][1]
 1147:               
 1148:             file2=file(os.path.join(folderName,f))   
 1149:             id=f
 1150:             manage_addCDLIFile(fobj2,f,'','')
 1151:             id=f
 1152:             ob=fobj2._getOb(f)
 1153:             ob.title=id
 1154:             
 1155:             manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='')
 1156:             self.CDLICatalog.catalog_object(ob)
 1157:             #self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)
 1158:             #self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])
 1159:             
 1160:         return "ok"
 1161:     
 1162: manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())
 1163: 
 1164:     
 1165: def manage_addCDLIFileFolder(self, id, title='',
 1166:                      createPublic=0,
 1167:                      createUserF=0,
 1168:                      REQUEST=None):
 1169:     """Add a new Folder object with id *id*.
 1170: 
 1171:     If the 'createPublic' and 'createUserF' parameters are set to any true
 1172:     value, an 'index_html' and a 'UserFolder' objects are created respectively
 1173:     in the new folder.
 1174:     """
 1175:     ob=CDLIFileFolder()
 1176:     ob.id=str(id)
 1177:     ob.title=title
 1178:     self._setObject(id, ob)
 1179:     ob=self._getOb(id)
 1180: 
 1181:     checkPermission=getSecurityManager().checkPermission
 1182: 
 1183:     if createUserF:
 1184:         if not checkPermission('Add User Folders', ob):
 1185:             raise Unauthorized, (
 1186:                   'You are not authorized to add User Folders.'
 1187:                   )
 1188:         ob.manage_addUserFolder()
 1189: 
 1190:   
 1191:     if REQUEST is not None:
 1192:         return self.manage_main(self, REQUEST, update_menu=1)
 1193: 
 1194: 

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