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