Annotation of cdli/cdli_files.py, revision 1.5

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

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