Annotation of cdli/cdli_basket.py, revision 1.1
1.1 ! dwinter 1: """CDLI extensions of the filearchive"""
! 2: from Products.versionedFile.extVersionedFile import *
! 3: from Products.ZCatalog.CatalogPathAwareness import CatalogAware
! 4: import os.path
! 5: import os
! 6: import urlparse
! 7: import urllib
! 8: import cgi
! 9: from OFS.OrderedFolder import OrderedFolder
! 10: from OFS.SimpleItem import SimpleItem
! 11: import time
! 12: from OFS.Folder import manage_addFolder
! 13: import re
! 14: from AccessControl import ClassSecurityInfo
! 15: from Acquisition import Implicit
! 16: from Globals import Persistent
! 17: from threading import Thread
! 18: from ZPublisher.HTTPRequest import HTTPRequest
! 19: from ZPublisher.HTTPResponse import HTTPResponse
! 20: from ZPublisher.BaseRequest import RequestContainer
! 21: import threading
! 22: import logging
! 23: import transaction
! 24: import copy
! 25: import codecs
! 26: import sys
! 27: from BTrees.IOBTree import IOBTree
! 28: import cdliSplitter
! 29: from sets import Set
! 30: import md5
! 31: from DownloadBasket import DownloadBasketFinallyThread
! 32: from types import *
! 33: import pickle
! 34: import tempfile
! 35:
! 36: from cdli_helpers import *
! 37: class BasketContent(SimpleItem):
! 38: """classe fuer den Inhalt eines Baskets"""
! 39:
! 40: def getFileAndVersionFromId(self,pnum,versionNr):
! 41:
! 42: obj=self.cdliRoot.getFileObject(pnum)
! 43: logging.debug("obj : %s"%obj)
! 44: version=obj.getVersionNr(versionNr)
! 45: logging.debug("-------vs: %s"%version.getFileName())
! 46: return version,obj
! 47:
! 48: def __init__(self,content=[]):
! 49: """content"""
! 50:
! 51: self.setContent(content[0:])
! 52:
! 53: def getContent(self,filtered=True):
! 54: return self.contentList
! 55:
! 56: def getContentOld(self,filtered=True):
! 57: """get content"""
! 58: logging.debug("content object: content List %s"%self.contentList)
! 59: ret=[]
! 60:
! 61: return [self.getFileAndVersionFromId(x[0],x[1]) for x in self.contentList]
! 62: #
! 63: # if filtered:
! 64: # for x in self.contentList:
! 65: # if not((x[0] is None) or (x[1] is None)):
! 66: # ret.append(x)
! 67: # logging.debug("content object: content List -done filtered")
! 68: # return ret
! 69: #
! 70: # else:
! 71: # logging.debug("content object: content List -done not filtered")
! 72: # return self.contentList
! 73:
! 74: def allContent(self):
! 75: """get all content"""
! 76: return self.getContent(filtered=False)
! 77:
! 78: def setContent(self,content):
! 79: contentList=[]
! 80: for x in content:
! 81: if not((x[0] is None) or (x[1] is None)):
! 82:
! 83: contentList.append((x[1].getId(),x[0].getVersionNumber()))
! 84: logging.debug("cl: %s"%contentList)
! 85: self.contentList=contentList[0:]
! 86:
! 87: def numberOfItems(self):
! 88: """number"""
! 89:
! 90: return len(self.getContent())
! 91:
! 92:
! 93: class uploadATFfinallyThread(Thread):
! 94: """class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
! 95:
! 96: def __init__(self):
! 97: """init for uploadATFfinallyThread"""
! 98: self.continueVar=True
! 99: self.returnValue=None
! 100: self.end=False
! 101: Thread.__init__(self)
! 102:
! 103: def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):
! 104: """set start values for the thread"""
! 105: self.procedure=procedure
! 106: self.comment=comment
! 107: self.basketname=basketname
! 108: self.unlock=unlock
! 109: self.SESSION=SESSION
! 110: self.username=username
! 111: self.serverport=serverport
! 112:
! 113:
! 114: def __call__(self):
! 115: """call of the thread (equals run)"""
! 116: self.run()
! 117: return True
! 118:
! 119: def getContext(self, app,serverport="8080"):
! 120: """get the context within the ZODB"""
! 121:
! 122: resp = HTTPResponse(stdout=None)
! 123: env = {
! 124: 'SERVER_NAME':'localhost',
! 125: 'SERVER_PORT':serverport,
! 126: 'REQUEST_METHOD':'GET'
! 127: }
! 128: req = HTTPRequest(None, env, resp)
! 129: return app.__of__(RequestContainer(REQUEST = req))
! 130:
! 131:
! 132: def run(self):
! 133: """run"""
! 134:
! 135: self.result=""
! 136: #find context within ZODB
! 137: from Zope import DB
! 138: conn = DB.open()
! 139: root = conn.root()
! 140: app = root['Application']
! 141: ctx = self.getContext(app,serverport=self.serverport)
! 142:
! 143: #add the files
! 144: self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
! 145: #commit the transactions
! 146: transaction.get().commit()
! 147: conn.close()
! 148: #set flag for end of this method
! 149: self.end=True
! 150: logging.info("ended")
! 151: return True
! 152:
! 153: def __del__(self):
! 154: """delete"""
! 155:
! 156:
! 157:
! 158: def getResult(self):
! 159: """method for accessing result"""
! 160:
! 161: return self.result
! 162:
! 163: def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
! 164: """upload the files"""
! 165: #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
! 166: ctx2=ctx.cdliRoot
! 167:
! 168: self.result+="<h2>Start processing</h2>"
! 169:
! 170: #shall I only upload the changed files?
! 171: logging.debug("uploadATFfinally procedure: %s"%procedure)
! 172: if procedure=="uploadchanged":
! 173: changed=[x[0] for x in SESSION.get('changed',[])]
! 174: uploadFns=changed+SESSION.get('newPs',[])
! 175:
! 176: #or all
! 177: elif procedure=="uploadAll":
! 178: uploadFns=[]
! 179: for x in os.listdir(SESSION['tmpdir']):
! 180: if not x in SESSION['lockerrors']:
! 181: uploadFns.append(x)
! 182:
! 183: #or maybe nothing
! 184: elif procedure=="noupload":
! 185: return True
! 186: else:
! 187: uploadFns=[]
! 188:
! 189: #do first the changed files
! 190: i=0
! 191: for fn in uploadFns:
! 192: logging.debug("uploadATFfinally uploadFn=%s"%fn)
! 193: i+=1
! 194: founds=ctx2.CDLICatalog.search({'title':fn})
! 195: if len(founds)>0:
! 196: SESSION['author']=str(username)
! 197: self.result="<p>Changing : %s"%fn+self.result
! 198: logging.debug("uploadatffinallythread changing:%s"%fn+self.result)
! 199: founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
! 200: if i%200==0:
! 201: transaction.get().commit()
! 202: logging.debug("uploadatffinallythread changing: do commit")
! 203:
! 204: transaction.get().commit()
! 205: logging.debug("uploadatffinallythread changing: last commit")
! 206:
! 207: #now add the new files
! 208: newPs=SESSION['newPs']
! 209: if len(newPs)>0:
! 210: tmpDir=SESSION['tmpdir']
! 211: logging.debug("uploadatffinallythread adding start")
! 212: self.result="<p>Adding files</p>"+self.result
! 213: #TODO: make this configurable, at the moment base folder for the files has to be cdli_main
! 214: ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
! 215: logging.debug("uploadatffinallythread adding finished")
! 216:
! 217: #unlock locked files?
! 218: if unlock:
! 219: logging.debug("uploadatffinallythread unlocking start")
! 220: self.result="<p>Unlock files</p>"+self.result
! 221: unlockFns=[]
! 222: for x in os.listdir(SESSION['tmpdir']):
! 223: if not x in SESSION['errors']:
! 224: unlockFns.append(x)
! 225:
! 226: logging.debug("unlocking have now what to unlock")
! 227:
! 228: for fn in unlockFns:
! 229: #logging.info("will unlock: %s"%fn)
! 230: founds=ctx2.CDLICatalog.search({'title':fn})
! 231: #logging.info("found it: %s"%repr(founds))
! 232: if len(founds)>0:
! 233: #logging.info("unlock: %s"%founds[0].getObject().getId())
! 234: SESSION['author']=str(username)
! 235: founds[0].getObject().lockedBy=""
! 236:
! 237: logging.debug("uploadatffinallythread unlocking done")
! 238:
! 239: #if a basketname is given, add files to the basket
! 240: if not (basketname ==''):
! 241: logging.debug("uploadatffinallythread add to basket %s"%basketname)
! 242: self.result="<p>Add to basket</p>"+self.result
! 243: basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
! 244:
! 245: if not basketId: # create new basket
! 246: logging.debug("uploadatffinallythread create basket %s"%basketname)
! 247: self.result="<p>Create a new basket</p>"+self.result
! 248: ob=ctx2.basketContainer.addBasket(basketname)
! 249: basketId=ob.getId()
! 250: basket=getattr(ctx2.basketContainer,str(basketId))
! 251: ids=os.listdir(SESSION['tmpdir'])
! 252: #logging.debug("should add:"+repr(ids))
! 253: basket.addObjects(ids,deleteOld=True,username=str(username))
! 254:
! 255: logging.debug("uploadatffinallythread uploadfinally done")
! 256:
! 257: if RESPONSE is not None:
! 258: RESPONSE.redirect(self.aq_parent.absolute_url())
! 259:
! 260: return True
! 261:
! 262: class tmpStore(SimpleItem):
! 263: """simple item"""
! 264: meta_type="cdli_upload"
! 265:
! 266: def __init__(self,id):
! 267: """init tmp"""
! 268: self.id=id
! 269:
! 270: class uploadATFThread(Thread):
! 271: """class for checking the files befor uploading"""
! 272:
! 273: def __init__(self):
! 274: """initialise"""
! 275:
! 276: self.continueVar=True
! 277: self.returnValue=None
! 278:
! 279: Thread.__init__(self)
! 280:
! 281:
! 282: def set(self,upload,basketId,username,idTmp,serverport="8080"):
! 283: """set start values for the thread"""
! 284: self.result=""
! 285: self.upload=upload
! 286: self.basketId=basketId
! 287: self.username=username
! 288: self.serverport=serverport
! 289: self.idTmp=idTmp
! 290:
! 291: def __call__(self):
! 292: """call method """
! 293: self.run()
! 294: return True
! 295:
! 296: def getContext(self, app,serverport="8080"):
! 297: """get the context within the ZODB"""
! 298: resp = HTTPResponse(stdout=None)
! 299: env = {
! 300: 'SERVER_NAME':'localhost',
! 301: 'SERVER_PORT':serverport,
! 302: 'REQUEST_METHOD':'GET'
! 303: }
! 304: req = HTTPRequest(None, env, resp)
! 305: return app.__of__(RequestContainer(REQUEST = req))
! 306:
! 307: def run(self):
! 308: idTmp=self.idTmp
! 309: self.result=""
! 310: #find context within ZODB
! 311: from Zope import DB
! 312: conn = DB.open()
! 313: root = conn.root()
! 314: app = root['Application']
! 315: ctx = self.getContext(app,serverport=self.serverport)
! 316: logging.info("run intern")
! 317: try:
! 318: logging.info("created: %s"%idTmp)
! 319: ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
! 320: except:
! 321: logging.error("thread upload: %s %s"%sys.exc_info()[0:2])
! 322:
! 323: logging.info("call thread intern")
! 324: self.uploadATFThread(ctx,self.upload,idTmp,self.basketId)
! 325:
! 326: #ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue
! 327:
! 328:
! 329: transaction.get().commit()
! 330:
! 331: conn.close()
! 332:
! 333: return getattr(ctx.temp_folder,idTmp)
! 334:
! 335: def getResult(self):
! 336: """method for accessing result"""
! 337: return self.result
! 338:
! 339: def uploadATFThread(self,ctx,upload,idTmp,basketId=0):
! 340: """upload an atf file"""
! 341: #TODO: add comments
! 342: #TODO: finish uploadATF
! 343:
! 344: stObj=getattr(ctx.temp_folder,idTmp)
! 345: logging.info("start, upload thread")
! 346: self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"
! 347:
! 348: #make sure that id is a string and not an integer
! 349: basketId=str(basketId)
! 350:
! 351: #TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
! 352: ctx2=ctx.cdliRoot
! 353:
! 354: #get temporary file for staging the downloaded and splitted files
! 355: dir=tempfile.mkdtemp()
! 356:
! 357:
! 358: changed=[] # changed files
! 359: errors=[] # files with errors
! 360: lockerrors=[] # files with errors
! 361:
! 362: newPs=[] # new p filed
! 363: psNotInCatalog=[] # files not in the catalog
! 364:
! 365: #split the uploadedd atf file
! 366: basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)
! 367:
! 368: #find basketId if not set
! 369:
! 370: #get active abaket
! 371: if basketId == '0':
! 372: basketObj=ctx2.basketContainer.getActiveBasket()
! 373: if basketObj:
! 374: basketId=basketObj.getId()
! 375:
! 376: #if there is no active basket and no basketid given, id is empty, else get besketname and length
! 377: if basketId == '0':
! 378: basketNameFromId=""
! 379: basketLen=0
! 380: else:
! 381: basketNameFromId=getattr(ctx2.basketContainer,basketId).title
! 382: basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()
! 383:
! 384: logging.info("got the file, upload thread")
! 385: self.result+="""<html><body><h2>I got the files</h2><
! 386: p>I am computing the differences to the exisiting files</p>"""
! 387:
! 388: #start to check the files
! 389: for fn in os.listdir(dir):
! 390:
! 391: self.result="<p>process:%s</p>"%fn+self.result
! 392:
! 393: # check if file is in the catalog
! 394: #TODO: checkCatalog is not implemented yet
! 395: if ctx2.cdli_main.checkCatalog(fn):
! 396: psNotInCatalog.append(fn)
! 397:
! 398: #check if p-file already at the server
! 399: founds=ctx2.CDLICatalog.search({'title':fn})
! 400:
! 401: #if not than add filename to the list of newfiles
! 402:
! 403: data=file(os.path.join(dir,fn)).read()
! 404: status,msg=checkFile(fn,data,dir)
! 405: #status=True
! 406:
! 407:
! 408: if not status: # error
! 409: errors.append((fn,msg))
! 410:
! 411: else:
! 412: if len(founds)==0:
! 413: newPs.append(fn)
! 414:
! 415: #if p file alread at the server
! 416: for found in founds:
! 417: #analyse the differences to the actual file
! 418: obj=found.getObject()
! 419:
! 420: if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
! 421: lockerrors.append((fn,str(obj.lockedBy)))
! 422: else:
! 423:
! 424: diffs=obj.diff(data)
! 425: if diffs[0]>0:
! 426: changed.append((obj,diffs)) #hochladen
! 427:
! 428: #ready, set the returnValues
! 429: self.result+="<h3>Done</h3></body></html>"
! 430:
! 431: stObj.returnValue={}
! 432:
! 433: stObj.returnValue['errors']=errors
! 434:
! 435: stObj.returnValue['newPs']=newPs
! 436: stObj.returnValue['tmpdir']=dir
! 437: stObj.returnValue['basketLen']=basketLen
! 438: stObj.returnValue['numberOfFiles']=numberOfFiles
! 439: stObj.returnValue['basketNameFromId']=basketNameFromId
! 440: stObj.returnValue['basketNameFromFile']=basketNameFromFile
! 441: stObj.returnValue['basketId']=basketId
! 442: stObj.returnValue['dir']=dir
! 443: #stObj.returnValue['changed']=copy.copy(changed)
! 444: stObj.returnValue['changed']=[(x[0].getId(),x[1][0]) for x in changed]
! 445: #stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors]
! 446: stObj.returnValue['lockerrors']=[x for x in lockerrors]
! 447: self.returnValue=True
! 448: #ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
! 449:
! 450: class CDLIBasketContainer(OrderedFolder):
! 451: """contains the baskets"""
! 452:
! 453:
! 454: security=ClassSecurityInfo()
! 455: meta_type="CDLIBasketContainer"
! 456:
! 457: def getResultHash(self):
! 458: """get the result hash for debug purposes"""
! 459: return self.resultHash.keys()
! 460:
! 461: def getPNumbersOfBasket(self,basketName):
! 462: """get all pnumbers of a basket as a list, returns an empty list if basket not found
! 463: @param basketName: name of the basket
! 464: """
! 465: ret=[]
! 466: basketId=self.getBasketIdfromName(basketName)
! 467: if not basketId:
! 468: return []
! 469:
! 470: ob=getattr(self,basketId).getContent() #get the content of a basket
! 471:
! 472: ret=[x[0].split(".")[0] for x in ob]
! 473:
! 474: return ret
! 475:
! 476: security.declareProtected('manage','getBasketAsOneFile')
! 477: def getBasketAsOneFile(self,basketName,current="no"):
! 478: """returns all files of the basket combined in one file
! 479: @param basketName: Name of the basket
! 480: @param current: (optional) if current is set to "yes" then the most current version of
! 481: all files are downloaded and not the versions of the files as stored in the basket
! 482: """
! 483: ret=""
! 484: basketId=self.getBasketIdfromName(basketName)
! 485: if not basketId:
! 486: return ""
! 487:
! 488: ob=getattr(self,basketId).getLastVersion()
! 489: for pnum,versionNr in ob.getContent():
! 490: obj=self.cdliRoot.getFileObject(pnum)
! 491: # logging.debug("obj : %s"%obj)
! 492: # version=obj.getVersionNr(versionNr)
! 493:
! 494: if current=="no": #version as they are in the basket
! 495: cur= obj.getVersionNr(versionNr)
! 496: ret+=str(cur.getData())+"\n"
! 497: elif current=="yes":
! 498: #search current object
! 499: #logging.debug("current: %s"%object[1].getId().split(".")[0])
! 500: obj.getData()
! 501: return ret
! 502:
! 503: security.declareProtected('manage','upDateBaskets')
! 504: def upDateBaskets(self):
! 505: """update content in to objects"""
! 506:
! 507: founds=self.ZopeFind(self,obj_metatypes=['CDLIBasketVersion'],search_sub=1)
! 508:
! 509: for found in founds:
! 510: found[1].updateBasket()
! 511:
! 512: security.declareProtected('manage','deleteBaskets')
! 513: def deleteBaskets(self,ids=None):
! 514: """delete baskets, i.e. move them into trash folder"""
! 515:
! 516: if ids is None:
! 517: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
! 518: txt="Sorry, no basket selected!"
! 519: return pt(txt=txt)
! 520:
! 521: found=self.ZopeFind(self,obj_ids=['trash'])
! 522:
! 523: if len(found)<1:
! 524: manage_addFolder(self, 'trash')
! 525: trash=self._getOb('trash')
! 526: else:
! 527: trash=found[0][1]
! 528:
! 529: if type(ids) is not ListType:
! 530: ids=[ids]
! 531: logging.error("XERXON:"+repr(ids))
! 532: if len(ids)==0:
! 533: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
! 534: txt="Sorry, no basket selected!"
! 535: return pt(txt=txt)
! 536:
! 537: cut=self.manage_cutObjects(ids)
! 538: trash.manage_pasteObjects(cut)
! 539: return None
! 540: security.declareProtected('manage','manageBaskets')
! 541: def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):
! 542: """manage baskets, delete or copy"""
! 543: if submit=="delete":
! 544: ret= self.deleteBaskets(ids)
! 545: if ret:
! 546: return ret
! 547: elif submit=="join":
! 548: flag,msg=self.joinBasket(joinBasket, ids)
! 549: logging.info("joining %s %s"%(flag,msg))
! 550: if not flag:
! 551: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
! 552:
! 553: return pt(txt=msg)
! 554:
! 555: elif submit=="subtract":
! 556: logging.info("BBBb %s %s"%(basket1,basket2))
! 557: flag,msg=self.subtractBasket(subtractBasket, basket1,basket2)
! 558: logging.info("subtract %s %s"%(flag,msg))
! 559:
! 560: if RESPONSE:
! 561: RESPONSE.redirect(self.absolute_url())
! 562:
! 563: security.declareProtected('View','getBasketIdfromName')
! 564: def getBasketIdfromName(self,basketname):
! 565: """get id from name"""
! 566:
! 567: for basket in self.ZopeFind(self,obj_metatypes=["CDLIBasket"]):
! 568: if basket[1].title==basketname:
! 569: return basket[0]
! 570: else:
! 571: None
! 572:
! 573: security.declareProtected('manage','uploadBasket_html')
! 574:
! 575: def uploadBasket_html(self,basketId='0'):
! 576: """upload an atf file, html form"""
! 577:
! 578:
! 579: basketId=str(basketId)
! 580: if not basketId=='0':
! 581: basketName=getattr(self.basketContainer,basketId).title
! 582: else:
! 583: basketName=""
! 584:
! 585: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadBasket_html.zpt')).__of__(self)
! 586: return pt(basketId=basketId,basketName=basketName)
! 587:
! 588:
! 589: security.declareProtected('manage','index_html')
! 590: def index_html(self):
! 591: """stanadard ansicht"""
! 592:
! 593:
! 594:
! 595: ext=self.ZopeFind(self,obj_ids=["index.html"])
! 596: if ext:
! 597: return ext[0][1]()
! 598:
! 599: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketContainerMain')).__of__(self)
! 600: return pt()
! 601:
! 602: def getStorageFolderRoot(self):
! 603: """root des storage folders"""
! 604: return self.cdli_main
! 605:
! 606: def __init__(self,id,title):
! 607: """ init basket container"""
! 608: self.id=id
! 609: self.title=title
! 610:
! 611:
! 612: def getBasketsId(self):
! 613: """get all baskets als klartext"""
! 614:
! 615: ret=""
! 616: baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
! 617: for basket in baskets:
! 618: com,user,time,values = basket[1].getContentIds()
! 619: ret+= "BASKET:"+com+"\t"+user+"\t"+time+"\n"
! 620: for x in values:
! 621: ret+= x[0]+"\t"+x[1]+"\n"
! 622: return ret
! 623:
! 624: def getBaskets(self,sortField='title'):
! 625: """get all baskets files"""
! 626:
! 627: def sortName(x,y):
! 628: return cmp(x[1].title.lower(),y[1].title.lower())
! 629:
! 630: def sortDate(x,y):
! 631: return cmp(y[1].getLastVersion().getTime(),x[1].getLastVersion().getTime())
! 632:
! 633:
! 634: def sortComment(x,y):
! 635:
! 636:
! 637:
! 638: try:
! 639: xc=getattr(x[1],'comment','ZZZZZZZZZZZZZ').lower()
! 640: except:
! 641: xc='ZZZZZZZZZZZZZ'.lower()
! 642: try:
! 643: yc=getattr(y[1],'comment','ZZZZZZZZZZZZZ').lower()
! 644: except:
! 645: yc='ZZZZZZZZZZZZZ'.lower()
! 646:
! 647:
! 648: if (xc=='') or (xc=='ZZZZZZZZZZZZZ'.lower()):
! 649:
! 650: try:
! 651: xc=x[1].getLastVersion().getComment().lower()
! 652: except:
! 653: xc='ZZZZZZZZZZZZZ'.lower()
! 654:
! 655: if (yc=='') or (yc=='ZZZZZZZZZZZZZ'.lower()):
! 656: try:
! 657: yc=y[1].getLastVersion().getComment().lower()
! 658: except:
! 659: yc='ZZZZZZZZZZZZZ'.lower()
! 660:
! 661:
! 662: return cmp(xc,yc)
! 663:
! 664: def sortAuthor(x,y):
! 665:
! 666: return cmp(x[1].getLastVersion().getUser().lower(),y[1].getLastVersion().getUser().lower())
! 667:
! 668: baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
! 669:
! 670:
! 671: if sortField=='title':
! 672: baskets.sort(sortName)
! 673: elif sortField=='date':
! 674: baskets.sort(sortDate)
! 675: elif sortField=='author':
! 676: baskets.sort(sortAuthor)
! 677: elif sortField=='comment':
! 678: baskets.sort(sortComment)
! 679:
! 680: return baskets
! 681:
! 682:
! 683: def subtractBasket(self,newBasket,basket1,basket2):
! 684: """subtract basket2 from basket1
! 685: (i.e. newbasket will contain alle elements of basket1 which are not in basket2),
! 686: if basket2 contains files which are not in basket1, then theses files fill be ignored
! 687:
! 688: @param newbasket: name of the new basket
! 689: @param basket1: basket where basket2 will be subtracted from
! 690: @param basket2: see above
! 691:
! 692: """
! 693:
! 694: logging.info("CCCCC %s %s"%(basket1,basket2))
! 695:
! 696: try:
! 697: newB=self.addBasket(newBasket)
! 698: except:
! 699: return False, "cannot create the new basket"
! 700:
! 701:
! 702:
! 703:
! 704:
! 705: bas2= getattr(self,basket2)
! 706: bas2content=bas2.getContent()
! 707: bas2ids=[x[0] for x in bas2content]
! 708:
! 709:
! 710:
! 711: bas1= getattr(self,basket1)
! 712: bas1content=bas1.getContent()
! 713:
! 714:
! 715: newBasketContent={}
! 716:
! 717: for id,version in bas1content:
! 718: if not (id in bas2ids):
! 719: newBasketContent[id]=version
! 720:
! 721: username=self.getActualUserName()
! 722:
! 723: logging.info("sbc %s"%newBasketContent)
! 724: newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
! 725:
! 726: return True, ""
! 727:
! 728:
! 729: def joinBasket(self,newBasket,oldBaskets):
! 730: """join two baskets
! 731: @param newbasket: name of the new basket
! 732: @param oldbaskets: list of baskets to be joined
! 733: """
! 734: if oldBaskets is None:
! 735: return False, "No Baskets selected!"
! 736:
! 737: try:
! 738: newB=self.addBasket(newBasket)
! 739: except:
! 740: return False, "cannot create the new basket"
! 741:
! 742: newBasketContent={}
! 743:
! 744: for ob in oldBaskets:
! 745: x= getattr(self,ob,None)
! 746: if x is None:
! 747: return False, "cannot find basket: %s"%ob
! 748:
! 749: ids=x.getContent() # hole den Inhalt
! 750:
! 751: for id,version in ids:
! 752: if newBasketContent.has_key(id): # p number gibt's schon
! 753: newBasketContent[id]=max(newBasketContent[id],version) # speichere die groessere Versionsnumber
! 754: else:
! 755: newBasketContent[id]=version
! 756: username=self.getActualUserName()
! 757:
! 758: logging.info("nbc %s"%newBasketContent)
! 759: newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)
! 760:
! 761: return True, ""
! 762:
! 763: def getNewId(self):
! 764: """createIds"""
! 765: last=getattr(self,'last',0)
! 766: last +=1
! 767: while len(self.ZopeFind(self,obj_ids=[str(last)]))>0:
! 768: last+=1
! 769:
! 770: self.last=last
! 771: return last
! 772:
! 773: def setActiveBasket(self,basketId,REQUEST=None):
! 774: """store active basketId in a cookie"""
! 775: self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
! 776: try:
! 777: qs=cgi.parse_qs(REQUEST['QUERY_STRING'])
! 778: del(qs['basketId'])
! 779: except:
! 780: qs={}
! 781: if REQUEST:
! 782: REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+urllib.urlencode(qs))
! 783:
! 784: def getActiveBasket(self):
! 785: """get active basket from cookie"""
! 786:
! 787: id= self.REQUEST.cookies.get('CDLIActiveBasket',None)
! 788: if id:
! 789: obj=getattr(self,str(id),None)
! 790: else:
! 791: obj=None
! 792: return obj
! 793:
! 794: def getActualUserName(self):
! 795: """get name of the actualuser"""
! 796: return str(self.REQUEST['AUTHENTICATED_USER'])
! 797:
! 798: security.declareProtected('manage','addBasket')
! 799: def addBasket(self,newBasketName):
! 800: """add a new basket"""
! 801:
! 802: ob=manage_addCDLIBasket(self,newBasketName)
! 803: return ob
! 804:
! 805: def storeInBasket(self,submit,ids=None,newBasketName=None,fromFileList=None,RESPONSE=None,REQUEST=None):
! 806: """store it"""
! 807: if not ids:
! 808: ids=self.REQUEST.SESSION['fileIds']
! 809:
! 810: if (type(ids) is not ListType) and (not isinstance(ids,Set)):
! 811: ids=[ids]
! 812:
! 813: if isinstance(ids,Set):
! 814: ids=list(ids)
! 815:
! 816: if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
! 817: basketRet=self.addBasket(newBasketName)
! 818: self.setActiveBasket(basketRet.getId())
! 819: basket=getattr(self,basketRet.getId())
! 820: elif (submit.lower()=="store in active basket") or (submit.lower()=="active basket"):
! 821: basket=self.getActiveBasket()
! 822:
! 823: added=basket.addObjects(ids)
! 824: back=self.REQUEST['HTTP_REFERER'].split("?")[0]+"?basketName="+basket.title+"&numberOfObjects="+str(added)
! 825:
! 826:
! 827: if fromFileList:
! 828:
! 829: return self.cdli_main.findObjectsFromList(list=ids,basketName=basket.title,numberOfObjects=added)
! 830:
! 831: if RESPONSE:
! 832:
! 833: RESPONSE.redirect(back)
! 834:
! 835: return True
! 836:
! 837: def manage_addCDLIBasketContainerForm(self):
! 838: """add the CDLIBasketContainer form"""
! 839: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasketContainer.zpt')).__of__(self)
! 840: return pt()
! 841:
! 842: def manage_addCDLIBasketContainer(self,id,title,RESPONSE=None):
! 843: """add the basket"""
! 844: ob=CDLIBasketContainer(id,title)
! 845:
! 846: self._setObject(id, ob)
! 847:
! 848: if RESPONSE is not None:
! 849: RESPONSE.redirect('manage_main')
! 850:
! 851: class CDLIBasket(Folder,CatalogAware):
! 852: """basket"""
! 853:
! 854: meta_type="CDLIBasket"
! 855: default_catalog="CDLIBasketCatalog"
! 856:
! 857: def searchInBasket(self,indexName,searchStr,regExp=False):
! 858: """searchInBasket"""
! 859:
! 860: lst=self.searchInLineIndexDocs(indexName,searchStr,uniq=True,regExp=regExp) #TODO: fix this
! 861: ret={}
! 862:
! 863: lv=self.getLastVersion()
! 864:
! 865:
! 866: for obj in lv.content.getContent():
! 867: id=obj[1].getId().split(".")[0]
! 868: if id in lst:
! 869:
! 870: ret[id]=self.showWordInFile(id,searchStr,lineList=self.getLinesFromIndex(indexName,searchStr,id,regExp=regExp),regExp=regExp,indexName=indexName)
! 871:
! 872:
! 873: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','searchResultsInBasket')).__of__(self)
! 874: return pt(result=ret,indexName=indexName,regExp=regExp,word=searchStr)
! 875:
! 876:
! 877:
! 878:
! 879: def searchInBasket_v1(self,searchStr):
! 880: """search occurences of searchStr in files im basket"""
! 881: ret=[]
! 882: lv=self.getLastVersion()
! 883: logging.info("searching")
! 884: for obj in lv.content.getContent():
! 885: txt=obj[0].getData()
! 886: for x in txt.split("\n"):
! 887: logging.info("search %s"%x)
! 888: if re.match(searchStr,x):
! 889: ret.append(x)
! 890:
! 891: return "\n".join(ret)
! 892:
! 893:
! 894: def getFile(self,obj):
! 895: return obj[1]
! 896:
! 897: def getFileLastVersion(self,obj):
! 898: return obj[0]
! 899:
! 900: def getFileNamesInLastVersion(self):
! 901: """get content of the last version as list"""
! 902:
! 903: return [x[1].getId() for x in self.getLastVersion().getContent()]
! 904:
! 905:
! 906: def isActual(self,obj,nummer):
! 907: """teste ob im basket die aktuelle version ist, obj kann entweder ein CDLIFile sein oder eine
! 908: eine pnummer, die auf ein CDLIFile verweist"""
! 909: try:
! 910: #logging.debug("isActual:"+repr(obj))
! 911: if isinstance(obj, CDLIFile):
! 912: actualNo=obj.getLastVersion().getVersionNumber()
! 913: else:
! 914: actualNo=self.cdliRoot.getFileObjectLastVersion(obj).getVersionNumber()
! 915:
! 916: if actualNo==nummer:
! 917: return True , 0
! 918: else:
! 919: return False, actualNo
! 920: except:
! 921: logging.error( """is actual: %s (%s %s)"""%(repr(obj),sys.exc_info()[0],sys.exc_info()[1]))
! 922: logging.error(""" PARAMS: %s %s"""%(obj,nummer))
! 923: return False, -1
! 924: def isActualOld(self,obj):
! 925: """teste ob im basket die aktuelle version ist"""
! 926: try:
! 927: #logging.debug("isActual:"+repr(obj))
! 928: actualNo=obj[1].getLastVersion().getVersionNumber()
! 929: storedNo=obj[0].getVersionNumber()
! 930:
! 931:
! 932: #actualNo=self.getFileObjectLastVersion(obj.getId()).getVersionNumber()
! 933:
! 934: #if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
! 935: # return False, -1
! 936:
! 937: if actualNo==storedNo:
! 938: return True , 0
! 939: else:
! 940: return False, actualNo
! 941: except:
! 942: logging.error( """is actual: %s (%s %s)"""%(repr(obj),sys.exc_info()[0],sys.exc_info()[1]))
! 943:
! 944: return False, -1
! 945:
! 946: def history(self):
! 947: """history"""
! 948:
! 949: ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
! 950: if ext:
! 951: return getattr(self,ext[0][1].getId())()
! 952:
! 953: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketHistory')).__of__(self)
! 954: return pt()
! 955:
! 956: def getStorageFolderRoot(self):
! 957: """root des storage folders"""
! 958: return self.aq_parent.cdli_main
! 959:
! 960: def __init__(self,id,title,shortDescription="",comment=""):
! 961: """init a CDLIBasket"""
! 962:
! 963: self.id=id
! 964: self.title=title
! 965: self.shortDescription=shortDescription
! 966: self.comment=comment
! 967:
! 968: def getActualUserName(self):
! 969: """get name of the actualuser"""
! 970:
! 971: return str(self.REQUEST['AUTHENTICATED_USER'])
! 972:
! 973:
! 974: def getLastVersion(self):
! 975: """hole letzte version"""
! 976:
! 977: ids=[]
! 978: idsTmp= self.objectIds()
! 979: for x in idsTmp:
! 980: try:
! 981: ids.append(int(x))
! 982: except:
! 983: pass
! 984: ids.sort()
! 985:
! 986: if len(ids)==0:
! 987: return None
! 988: else:
! 989: ob=getattr(self,str(ids[-1]))
! 990:
! 991:
! 992: return ob
! 993:
! 994: def getVersions(self):
! 995: """get versions"""
! 996: versions=self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])
! 997: return versions
! 998:
! 999:
! 1000: def updateObjects(self,ids,RESPONSE=None,REQUEST=None):
! 1001: """update ids, ids not in the basket the add"""
! 1002: if type(ids) is not ListType:
! 1003: ids=[ids]
! 1004:
! 1005: lastVersion=self.getLastVersion()
! 1006: oldContent=lastVersion.content.getContent()
! 1007: newContent=[]
! 1008:
! 1009: #first copy the old
! 1010: for obj in oldContent:
! 1011: if obj[1].getId() not in ids:
! 1012: newContent.append(obj)
! 1013: #now add the new
! 1014:
! 1015: for id in ids:
! 1016: founds=self.CDLICatalog.search({'title':id})
! 1017:
! 1018: for found in founds:
! 1019: if found.getObject() not in oldContent:
! 1020: #TODO: was passiert wenn, man eine Object dazufuegt, das schon da ist aber eine neuere version
! 1021: newContent.append((found.getObject().getLastVersion(),found.getObject()))
! 1022:
! 1023:
! 1024: content=newContent
! 1025: user=self.getActualUserName()
! 1026:
! 1027: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
! 1028:
! 1029: obj=self._getOb(ob.getId())
! 1030: if RESPONSE:
! 1031:
! 1032: RESPONSE.redirect(obj.absolute_url())
! 1033:
! 1034: return obj
! 1035:
! 1036: def addObjectsWithVersion(self,ids,deleteOld=None,username=None,catalog=None):
! 1037: """generate a new version of the basket with objects added,
! 1038: hier wird jedoch nicht die letzte Version jedes Files hinzugefuegt, s
! 1039: ondern ids is ein Tupel mit der Id (d.h. der p-number) und der Versionsnummer.
! 1040: """
! 1041: logging.info("add to basket (%s)"%(self.getId()))
! 1042: lastVersion=self.getLastVersion()
! 1043:
! 1044: if not catalog:
! 1045: catalog=self.CDLICatalog
! 1046:
! 1047: if lastVersion is None:
! 1048: oldContent=[]
! 1049: else:
! 1050: oldContent=lastVersion.content.getContent()
! 1051:
! 1052: if deleteOld:
! 1053: oldContent=[]
! 1054:
! 1055: newContent=[]
! 1056: added=0
! 1057:
! 1058: for id,version in ids.iteritems():
! 1059: logging.info("adding %s %s"%(id,version))
! 1060: id=id.split(".")[0] # title nur die pnumber ohne atf
! 1061:
! 1062: try:
! 1063: founds=catalog.search({'title':id})
! 1064: except:
! 1065: founds=[]
! 1066: logging.info(" found %s "%(founds))
! 1067: for found in founds:
! 1068: if found.getObject() not in oldContent:
! 1069:
! 1070: #TODO: was passiert wenn, man eine Object dazufuegt, das schon da ist aber eine neuere version
! 1071: newContent.append((found.getObject().getVersions()[version-1][1],found.getObject()))
! 1072: added+=1
! 1073:
! 1074: content=oldContent+newContent
! 1075: if not username:
! 1076: logging.error("XXXXXXXXXXX %s"%repr(self))
! 1077: user=self.getActualUserName()
! 1078: else:
! 1079: user = username
! 1080:
! 1081: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
! 1082: logging.info("add to basket (%s) done"%(self.getId()))
! 1083: return added
! 1084:
! 1085:
! 1086: def addObjects(self,ids,deleteOld=None,username=None):
! 1087: """generate a new version of the basket with objects added"""
! 1088:
! 1089: def swap(x):
! 1090: return (x[1],x[0])
! 1091:
! 1092: logging.info("add to basket (%s)"%(repr(ids)))
! 1093: logging.info("add to basket (%s)"%(self.getId()))
! 1094: lastVersion=self.getLastVersion()
! 1095:
! 1096: if lastVersion is None:
! 1097: oldContent=[]
! 1098: else:
! 1099: oldContent=lastVersion.content.getContent()
! 1100:
! 1101: if deleteOld:
! 1102: oldContent=[]
! 1103:
! 1104: added=0
! 1105: # for id in ids:
! 1106: # logging.debug("adding:"+id)
! 1107: # try:
! 1108: # founds=self.CDLICatalog.search({'title':id})
! 1109: # except:
! 1110: # founds=[]
! 1111: #
! 1112: # for found in founds:
! 1113: # if found.getObject() not in oldContent:
! 1114: # #TODO: was passiert wenn, man eine Object dazufugt, das schon da ist aber eine neuere version
! 1115: # newContent.append((found.getObject().getLastVersion(),found.getObject()))
! 1116: # added+=1
! 1117:
! 1118: hash = md5.new(repr(makelist(ids))).hexdigest() # erzeuge hash als identification
! 1119: #logging.debug("JJJJJJJ:"+repr(self.makelist(ids)))
! 1120:
! 1121: retrieved = self.CDLICache.retrieve(hash)
! 1122: if retrieved:
! 1123: newContent=Set(map(swap,retrieved))
! 1124: else:
! 1125: newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])
! 1126:
! 1127:
! 1128:
! 1129: #remove all Elements which are not stored
! 1130: if (None,None) in newContent:
! 1131: newContent.remove((None,None))
! 1132: content=Set(oldContent).union(newContent)
! 1133: added = len(content)-len(oldContent)
! 1134: if not username:
! 1135: user=self.getActualUserName()
! 1136: else:
! 1137: user = username
! 1138:
! 1139: #logging.debug("content:"+repr(list(content)))
! 1140: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=list(content))
! 1141: logging.info("add to basket (%s) done"%(self.getId()))
! 1142: return added
! 1143:
! 1144:
! 1145:
! 1146: def getContent(self):
! 1147: """print content"""
! 1148: ret=[]
! 1149:
! 1150: lv=self.getLastVersion()
! 1151: #for obj in lv.content.getContent():
! 1152: #logging.info("XXXXXXXXXX %s"%repr(obj))
! 1153: # ret.append((obj[1].getId(),obj[0].versionNumber))
! 1154:
! 1155: return lv
! 1156:
! 1157: def getContentIds(self):
! 1158: """print basket content"""
! 1159: ret=[]
! 1160: lv=self.getLastVersion()
! 1161: for obj in lv.content.getContent():
! 1162: ret.append((obj[0].getId(),obj[1].getId()))
! 1163:
! 1164:
! 1165: return lv.getComment(),lv.getUser(),lv.getTime(),ret
! 1166:
! 1167: def changeBasket(self,ids,submit,RESPONSE=None,REQUEST=None):
! 1168: """change a basket"""
! 1169: if submit=="update":
! 1170: return self.updateObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
! 1171: elif submit=="delete":
! 1172: return self.deleteObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
! 1173:
! 1174: def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
! 1175: """delete objects"""
! 1176:
! 1177: if type(ids) is not ListType:
! 1178: ids=[ids]
! 1179:
! 1180: lastVersion=self.getLastVersion()
! 1181: oldContent=lastVersion.content.getContent()
! 1182: newContent=[]
! 1183: for obj in oldContent:
! 1184: if obj[1].getId() not in ids:
! 1185: newContent.append(obj)
! 1186:
! 1187:
! 1188: user=self.getActualUserName()
! 1189:
! 1190: ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)
! 1191:
! 1192: if RESPONSE:
! 1193: obj=self._getOb(ob.getId())
! 1194: RESPONSE.redirect(obj.absolute_url())
! 1195:
! 1196: def manage_addCDLIBasketForm(self):
! 1197: """add the CDLIBasketContainer form"""
! 1198: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addCDLIBasket.zpt')).__of__(self)
! 1199: return pt()
! 1200:
! 1201: def manage_addCDLIBasket(self,title,shortDescription="",comment="",RESPONSE=None):
! 1202: """add the basket"""
! 1203:
! 1204: id=str(self.getNewId())
! 1205:
! 1206: ob=CDLIBasket(id,title,shortDescription,comment)
! 1207:
! 1208: self._setObject(id, ob)
! 1209:
! 1210: if RESPONSE is not None:
! 1211: RESPONSE.redirect('manage_main')
! 1212: else:
! 1213: return ob
! 1214:
! 1215:
! 1216:
! 1217: class CDLIBasketVersion(Implicit,Persistent,Folder):
! 1218: """version of a basket"""
! 1219:
! 1220: meta_type="CDLIBasketVersion"
! 1221: security=ClassSecurityInfo()
! 1222:
! 1223: def updateBasket(self):
! 1224: """update"""
! 1225: try:
! 1226: self._setObject('content',BasketContent(self.basketContent))
! 1227: except:
! 1228: try:
! 1229: if len(self.basketContent)>0:
! 1230: self.content.setContent(self.basketContent)
! 1231: except:
! 1232: print "error",self.getId(),self.aq_parent.getId()
! 1233: self.basketContent=[]
! 1234:
! 1235:
! 1236: def containsNonActualFiles(self):
! 1237: """returns True if basket contains one or more non current files"""
! 1238:
! 1239: objs=self.getContent()
! 1240: for obj in objs:
! 1241: if not self.isActual(obj[0],obj[1])[0]:
! 1242: return True
! 1243: return False
! 1244:
! 1245: def downloadListOfPnumbers(self):
! 1246: """download pnumbers of the basket as list"""
! 1247:
! 1248: basket_name=self.aq_parent.title
! 1249:
! 1250: ids=self.getContent() # get the list of objects
! 1251: logging.error(ids)
! 1252: ret="\n".join([x[1].getId().split(".")[0] for x in ids])
! 1253:
! 1254: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.txt" """%basket_name)
! 1255: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
! 1256: length=len(ret)
! 1257: self.REQUEST.RESPONSE.setHeader("Content-Length",length)
! 1258: self.REQUEST.RESPONSE.write(ret)
! 1259:
! 1260: security.declareProtected('manage','downloadObjectsAsOneFile')
! 1261: def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):
! 1262: """download all selected files in one file"""
! 1263:
! 1264: if self.temp_folder.downloadCounterBaskets > 10000:
! 1265: return """I am sorry, currently the server has to many requests for downloads, please come back later!"""
! 1266:
! 1267:
! 1268: #if (check=="yes") and self.containsNonActualFiles():
! 1269: # pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
! 1270: #
! 1271: # return pt(lock=lock)
! 1272:
! 1273: # neue Version aus Performancegruenden, es wird nicht mehr getestet, ob es nicht aktuelle Objekte gibt
! 1274: # sondern lediglich gefragt.
! 1275: if (check=="yes"):
! 1276: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_ask.zpt')).__of__(self)
! 1277:
! 1278: return pt(lock=lock)
! 1279:
! 1280: else:
! 1281:
! 1282: return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")
! 1283:
! 1284: def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no",repeat=None):
! 1285: """print do the download"""
! 1286:
! 1287:
! 1288: ret=""
! 1289: lockedObjects={}
! 1290:
! 1291:
! 1292:
! 1293: if lock:
! 1294: logging.debug("------lock:"+repr(lock))
! 1295: if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
! 1296:
! 1297: return "please login first"
! 1298:
! 1299: #check if a locked object exist in the basket.
! 1300: lockedObjects={}
! 1301: for object in self.content.getContent():
! 1302: obj=self.getFileObject(object[0])
! 1303: if (not str(obj.lockedBy)=="") and (not (str(obj.lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):
! 1304: lockedObjects[obj.title]=repr(obj.lockedBy)
! 1305:
! 1306:
! 1307: keys=lockedObjects.keys()
! 1308:
! 1309:
! 1310: if len(keys)>0 and (not procedure):
! 1311: self.REQUEST.SESSION['lockedObjects']=lockedObjects
! 1312: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
! 1313:
! 1314:
! 1315: return pt()
! 1316:
! 1317: elif not procedure: #keine fails gesperrt dann alle donwloaden
! 1318: procedure="downloadAll"
! 1319:
! 1320:
! 1321:
! 1322:
! 1323: threadName=repeat
! 1324: if not threadName or threadName=="":
! 1325: thread=DownloadBasketFinallyThread()
! 1326: threadName=thread.getName()[0:]
! 1327:
! 1328: if (not hasattr(self,'_v_downloadBasket')):
! 1329: self._v_downloadBasket={}
! 1330:
! 1331:
! 1332: self._v_downloadBasket[threadName]=thread
! 1333: logging.debug("dwonloadfinally:"+repr(self))
! 1334:
! 1335: if isinstance(self,CDLIBasketVersion):
! 1336: obj=self
! 1337: else:
! 1338: obj=self.aq_parent
! 1339: logging.debug("dwonloadfinally2:"+repr(obj))
! 1340: logging.debug("dwonloadfinally2:"+repr(obj.aq_parent))
! 1341:
! 1342: obj2=obj.aq_parent
! 1343: if not isinstance(obj2,CDLIBasket):
! 1344: obj2=obj2.aq_parent
! 1345:
! 1346: basketID=obj2.getId()
! 1347: versionNumber=obj.getId()
! 1348: logging.debug("dwonloadfinally2:"+repr(basketID))
! 1349: logging.debug("dwonloadfinally2:"+repr(versionNumber))
! 1350:
! 1351:
! 1352: if lock:
! 1353: logging.debug("-----start locking")
! 1354: for object in self.content.getContent():
! 1355: obj=self.getFileObject(object[0])
! 1356: if obj.lockedBy =='':
! 1357: obj.lockedBy=self.REQUEST['AUTHENTICATED_USER']
! 1358: logging.debug("-----finished locking")
! 1359:
! 1360: #obj.lockedBy=user
! 1361: self._v_downloadBasket[threadName].set(lock,procedure,self.REQUEST['AUTHENTICATED_USER'],current,basketID,versionNumber)
! 1362:
! 1363: self._v_downloadBasket[threadName].start()
! 1364:
! 1365:
! 1366:
! 1367: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
! 1368:
! 1369: if wait_template:
! 1370: return wait_template[0][1]()
! 1371: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadBasketWait.zpt')).__of__(self)
! 1372:
! 1373: return pt(txt=self.absolute_url()+'/downloadObjectsAsOneFileFinally',threadName=threadName,
! 1374: counter=self._v_downloadBasket[threadName].getCounter(),
! 1375: number=self._v_downloadBasket[threadName].getNumberOfFiles())
! 1376: #_v_xmltrans.run()
! 1377:
! 1378: else:
! 1379: #recover thread, if lost
! 1380: if not hasattr(self,'_v_downloadBasket'):
! 1381: self._v_downloadBasket={}
! 1382: if not self._v_downloadBasket.get(threadName,None):
! 1383: for thread in threading.enumerate():
! 1384: if threadName == thread.getName():
! 1385: self._v_downloadBasket[threadName]=thread
! 1386:
! 1387: if self._v_downloadBasket.get(threadName,None) and (self._v_downloadBasket[threadName] is not None) and (not self._v_downloadBasket[threadName].end) :
! 1388:
! 1389: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
! 1390: if wait_template:
! 1391: return wait_template[0][1]()
! 1392:
! 1393: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadBasketWait.zpt')).__of__(self)
! 1394: return pt(txt=self.absolute_url()+'/downloadObjectsAsOneFileFinally',threadName=threadName,
! 1395: counter=self._v_downloadBasket[threadName].getCounter(),
! 1396: number=self._v_downloadBasket[threadName].getNumberOfFiles())
! 1397: else:
! 1398:
! 1399:
! 1400: logging.debug("FINISHED")
! 1401: if not self._v_downloadBasket.get(threadName,None):
! 1402: for thread in threading.enumerate():
! 1403: if threadName == thread.getName():
! 1404: self._v_downloadBasket[threadName]=thread
! 1405:
! 1406: #files = self._v_downloadBasket[threadName].result
! 1407: # lade die files und die locked files, bei grossen Baskets muss u.U. gewartet werden
! 1408: # bis das Commit aus dem Thread alles geschrieben hat, in dem Falle existiert resultHash[threadName]
! 1409: # noch nicht.
! 1410: o1 = file("/tmp/"+threadName,'r')
! 1411: files=pickle.load(o1)
! 1412: os.remove("/tmp/"+threadName)
! 1413: o2 = file("/tmp/"+threadName+'_lockedFiles','r')
! 1414:
! 1415: lockedFiles=pickle.load(o2)
! 1416: os.remove("/tmp/"+threadName+'_lockedFiles')
! 1417: # try:
! 1418: # files=self.basketContainer.resultHash[threadName]
! 1419: # except:
! 1420: # i=0
! 1421: # while (not self.basketContainer.resultHash.has_key(threadName)) and (i<100):
! 1422: # logging.debug(" downloadFinally: I am waiting for thread %s to write the resultHashfile: %s"%(threadName,i))
! 1423: # time.sleep(5)
! 1424: # i+=1
! 1425: # files=self.basketContainer.resultHash[threadName]
! 1426: #
! 1427: # try:
! 1428: # lockedFiles=self.basketContainer.resultLockedHash[threadName]
! 1429: # except:
! 1430: # i=0
! 1431: # while (not self.basketContainer.resultLockedHash.has_key(threadName)) and (i<100):
! 1432: # logging.debug(" downloadFinally: I am waiting for thread %s to write the LockedHashfile: %s"%(threadName,i))
! 1433: # time.sleep(5)
! 1434: # i+=1
! 1435: # lockedFiles=self.basketContainer.resultLockedHash[threadName]
! 1436:
! 1437: # fh=file("/var/tmp/test")
! 1438: #ret =fh.read()
! 1439:
! 1440: if (not isinstance(self.aq_parent,CDLIBasket)):
! 1441: basket_name=self.aq_parent.aq_parent.title+"_V"+self.getId()
! 1442: else:
! 1443: basket_name=self.aq_parent.title+"_V"+self.getId()
! 1444:
! 1445:
! 1446:
! 1447: #write basketname to header of atf file
! 1448:
! 1449:
! 1450: self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
! 1451: self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
! 1452: #length=len(ret)
! 1453: #self.REQUEST.RESPONSE.setHeader("Content-Length",length)
! 1454:
! 1455: ret="#basket: %s\n"%basket_name
! 1456: self.REQUEST.RESPONSE.write(ret)
! 1457:
! 1458: for fileName in files:
! 1459: logging.debug("download: %s"%fileName)
! 1460: try:
! 1461: self.REQUEST.RESPONSE.write(file(fileName).read())
! 1462: except:
! 1463: logging.error("downloadasonefile: cannot read %s"%fileName)
! 1464:
! 1465:
! 1466: self.REQUEST.RESPONSE.write("\n# locked files\n")
! 1467: for fileName in lockedFiles:
! 1468: self.REQUEST.RESPONSE.write("# %s by %s\n"%fileName)
! 1469:
! 1470: self.REQUEST.RESPONSE.write("# locked files end\n")
! 1471:
! 1472: #del self.basketContainer.resultHash[threadName]
! 1473: #del self.basketContainer.resultLockedHash[threadName]
! 1474:
! 1475: def numberOfItems(self):
! 1476: """return anzahl der elemente im basket"""
! 1477: return self.content.numberOfItems()
! 1478:
! 1479: def getTime(self):
! 1480: """getTime"""
! 1481: #return self.bobobase_modification_time().ISO()
! 1482:
! 1483: if hasattr(self,'time'):
! 1484: return time.strftime("%Y-%m-%d %H:%M:%S",self.time)
! 1485: elif hasattr(self,'timefixed'):
! 1486: return self.timefixed
! 1487: else:
! 1488: setattr(self,'timefixed',self.bobobase_modification_time().ISO())
! 1489: return self.bobobase_modification_time().ISO()
! 1490:
! 1491: def getContent(self):
! 1492: """get Basket Content"""
! 1493: logging.debug("retrieving content A")
! 1494: cnt = self.content
! 1495: logging.debug("retrieving content: obj %s"%cnt)
! 1496: tmp = self.content.getContent()
! 1497: logging.debug("got content")
! 1498: return tmp
! 1499:
! 1500:
! 1501: def __init__(self,id,user,comment="",basketContent=[]):
! 1502: """ init a basket version"""
! 1503: self.id=id
! 1504: self.comment=comment
! 1505: self._setObject('content',BasketContent(basketContent))
! 1506: #self.basketContent=basketContent[0:]a
! 1507: self.user=user
! 1508: self.time=time.localtime()
! 1509:
! 1510: def getUser(self):
! 1511: """get user"""
! 1512: return self.user
! 1513:
! 1514: def getComment(self):
! 1515: """get Comment"""
! 1516: return self.comment
! 1517:
! 1518: security.declareProtected('manage','index_html')
! 1519: def index_html(self):
! 1520: """view the basket"""
! 1521: logging.debug("start index_html - Basket version")
! 1522: if self.REQUEST.get('change',False):
! 1523: ob=self.aq_parent.updateObjects(self.REQUEST['change'])
! 1524:
! 1525: self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket
! 1526: logging.debug("start index_html - Basket version:template")
! 1527: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
! 1528: return pt()
! 1529:
! 1530: def getObjUrl(self,result):
! 1531: """getUrl of the version of the object"""
! 1532:
! 1533: founds=self.CDLICatalog.search({'title':result})
! 1534: if len(founds)>0:
! 1535: return founds[0].getObject().getLastVersion().absolute_url()
! 1536:
! 1537: else: #assume version number
! 1538: splitted=result.split("_")
! 1539: founds=self.CDLICatalog.search({'title':splitted[1]})
! 1540: return founds[0].getObject().getLastVersion().absolute_url()+'/'+result
! 1541:
! 1542: def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
! 1543: """add a version"""
! 1544:
! 1545: #check for already existing versions
! 1546:
! 1547: lastVersion=self.getLastVersion()
! 1548: if lastVersion is None:
! 1549: newId=str(1)
! 1550: else:
! 1551: newId=str(int(lastVersion.getId())+1)
! 1552:
! 1553: ob=CDLIBasketVersion(newId,user,comment,basketContent)
! 1554:
! 1555: self._setObject(newId, ob)
! 1556:
! 1557: if RESPONSE is not None:
! 1558: RESPONSE.redirect('manage_main')
! 1559: else:
! 1560: return ob
! 1561:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to cdli_basket.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / cdli