cdli/cdli_files.py - diff

Return to cdli_files.py CVS log

Up to [Repository] / cdli

Diff for /cdli/cdli_files.py between versions 1.84 and 1.103

version 1.84, 2008/09/25 13:41:58	version 1.103, 2008/11/05 19:53:32
Line 1	Line 1
"""CDLI extensions of the filearchive"""	"""CDLI extensions of the filearchive"""
from Products.versionedFile.extVersionedFile import *	from Products.versionedFile.extVersionedFile import *
from Products.ZCatalog.CatalogPathAwareness import CatalogAware	from Products.ZCatalog.CatalogPathAwareness import CatalogAware
from tempfile import mkstemp,mkdtemp
import os.path	import os.path
import os	import os
from types import *
import urlparse	import urlparse
import urllib	import urllib
import cgi	import cgi
Line 21 from ZPublisher.HTTPRequest import HTTPR	Line 19 from ZPublisher.HTTPRequest import HTTPR
from ZPublisher.HTTPResponse import HTTPResponse	from ZPublisher.HTTPResponse import HTTPResponse
from ZPublisher.BaseRequest import RequestContainer	from ZPublisher.BaseRequest import RequestContainer
import threading	import threading
from BTrees.OOBTree import OOBTree, OOTreeSet
import logging	import logging
import transaction	import transaction
import copy	import copy
Line 31 from BTrees.IOBTree import IOBTree	Line 28 from BTrees.IOBTree import IOBTree
import cdliSplitter	import cdliSplitter
from sets import Set	from sets import Set
import md5	import md5
	from DownloadBasket import DownloadBasketFinallyThread
	from types import *
	import pickle

	def makelist(mySet):
	x = list(mySet)
	x.sort()
	return x

def unicodify(s):	def unicodify(s):
"""decode str (utf-8 or latin-1 representation) into unicode object"""	"""decode str (utf-8 or latin-1 representation) into unicode object"""
Line 218 def unique(s):	Line 223 def unique(s):
class BasketContent(SimpleItem):	class BasketContent(SimpleItem):
"""classe fuer den Inhalt eines Baskets"""	"""classe fuer den Inhalt eines Baskets"""

	def getFileAndVersionFromId(self,pnum,versionNr):

	obj=self.cdliRoot.getFileObject(pnum)
	logging.debug("obj : %s"%obj)
	version=obj.getVersionNr(versionNr)
	logging.debug("-------vs: %s"%version.getFileName())
	return version,obj

def __init__(self,content=[]):	def __init__(self,content=[]):
"""content"""	"""content"""
self.contentList=content[0:]

def getContent(self):	self.setContent(content[0:])
"""get content"""

	def getContent(self,filtered=True):
return self.contentList	return self.contentList

	def getContentOld(self,filtered=True):
	"""get content"""
	logging.debug("content object: content List %s"%self.contentList)
	ret=[]

	return [self.getFileAndVersionFromId(x[0],x[1]) for x in self.contentList]
	#
	# if filtered:
	# for x in self.contentList:
	# if not((x[0] is None) or (x[1] is None)):
	# ret.append(x)
	# logging.debug("content object: content List -done filtered")
	# return ret
	#
	# else:
	# logging.debug("content object: content List -done not filtered")
	# return self.contentList

	def allContent(self):
	"""get all content"""
	return self.getContent(filtered=False)

def setContent(self,content):	def setContent(self,content):
self.contentList=content[0:]	contentList=[]
	for x in content:
	if not((x[0] is None) or (x[1] is None)):

	contentList.append((x[1].getId(),x[0].getVersionNumber()))
	logging.debug("cl: %s"%contentList)
	self.contentList=contentList[0:]

def numberOfItems(self):	def numberOfItems(self):
"""number"""	"""number"""
Line 395 class uploadATFfinallyThread(Thread):	Line 435 class uploadATFfinallyThread(Thread):
basketId=ob.getId()	basketId=ob.getId()
basket=getattr(ctx2.basketContainer,str(basketId))	basket=getattr(ctx2.basketContainer,str(basketId))
ids=os.listdir(SESSION['tmpdir'])	ids=os.listdir(SESSION['tmpdir'])
	#logging.debug("should add:"+repr(ids))
basket.addObjects(ids,deleteOld=True,username=str(username))	basket.addObjects(ids,deleteOld=True,username=str(username))

logging.debug("uploadatffinallythread uploadfinally done")	logging.debug("uploadatffinallythread uploadfinally done")
Line 600 class CDLIBasketContainer(OrderedFolder)	Line 641 class CDLIBasketContainer(OrderedFolder)
security=ClassSecurityInfo()	security=ClassSecurityInfo()
meta_type="CDLIBasketContainer"	meta_type="CDLIBasketContainer"

	def getResultHash(self):
	"""get the result hash for debug purposes"""
	return self.resultHash.keys()

def getPNumbersOfBasket(self,basketName):	def getPNumbersOfBasket(self,basketName):
"""get all pnumbers of a basket as a list, returns an empty list if basket not found	"""get all pnumbers of a basket as a list, returns an empty list if basket not found
@param basketName: name of the basket	@param basketName: name of the basket
Line 609 class CDLIBasketContainer(OrderedFolder)	Line 654 class CDLIBasketContainer(OrderedFolder)
if not basketId:	if not basketId:
return []	return []

ob=getattr(self,basketId).getContent()	ob=getattr(self,basketId).getContent() #get the content of a basket

ret=[x[0].split(".")[0] for x in ob]	ret=[x[0].split(".")[0] for x in ob]

Line 628 class CDLIBasketContainer(OrderedFolder)	Line 673 class CDLIBasketContainer(OrderedFolder)
return ""	return ""

ob=getattr(self,basketId).getLastVersion()	ob=getattr(self,basketId).getLastVersion()
for object in ob.getContent():	for pnum,versionNr in ob.getContent():
	obj=self.cdliRoot.getFileObject(pnum)
	# logging.debug("obj : %s"%obj)
	# version=obj.getVersionNr(versionNr)

if current=="no": #version as they are in the basket	if current=="no": #version as they are in the basket
ret+=str(object[0].getData())+"\n"	cur= obj.getVersionNr(versionNr)
	ret+=str(cur.getData())+"\n"
elif current=="yes":	elif current=="yes":
#search current object	#search current object
logging.debug("current: %s"%object[1].getId().split(".")[0])	#logging.debug("current: %s"%object[1].getId().split(".")[0])
founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})	obj.getData()
if len(founds)>0:
ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
return ret	return ret

security.declareProtected('manage','upDateBaskets')	security.declareProtected('manage','upDateBaskets')
Line 652 class CDLIBasketContainer(OrderedFolder)	Line 700 class CDLIBasketContainer(OrderedFolder)
def deleteBaskets(self,ids=None):	def deleteBaskets(self,ids=None):
"""delete baskets, i.e. move them into trash folder"""	"""delete baskets, i.e. move them into trash folder"""

	if ids is None:
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
	txt="Sorry, no basket selected!"
	return pt(txt=txt)

found=self.ZopeFind(self,obj_ids=['trash'])	found=self.ZopeFind(self,obj_ids=['trash'])

Line 663 class CDLIBasketContainer(OrderedFolder)	Line 715 class CDLIBasketContainer(OrderedFolder)

if type(ids) is not ListType:	if type(ids) is not ListType:
ids=[ids]	ids=[ids]
	logging.error("XERXON:"+repr(ids))
	if len(ids)==0:
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)
	txt="Sorry, no basket selected!"
	return pt(txt=txt)

cut=self.manage_cutObjects(ids)	cut=self.manage_cutObjects(ids)
trash.manage_pasteObjects(cut)	trash.manage_pasteObjects(cut)
	return None
security.declareProtected('manage','manageBaskets')	security.declareProtected('manage','manageBaskets')
def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):	def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):
"""manage baskets, delete or copy"""	"""manage baskets, delete or copy"""
if submit=="delete":	if submit=="delete":
self.deleteBaskets(ids)	ret= self.deleteBaskets(ids)
	if ret:
	return ret
elif submit=="join":	elif submit=="join":
flag,msg=self.joinBasket(joinBasket, ids)	flag,msg=self.joinBasket(joinBasket, ids)
logging.info("joining %s %s"%(flag,msg))	logging.info("joining %s %s"%(flag,msg))
	if not flag:
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','cdliError_html.zpt')).__of__(self)

	return pt(txt=msg)

elif submit=="subtract":	elif submit=="subtract":
logging.info("BBBb %s %s"%(basket1,basket2))	logging.info("BBBb %s %s"%(basket1,basket2))
Line 814 class CDLIBasketContainer(OrderedFolder)	Line 877 class CDLIBasketContainer(OrderedFolder)
@param basket2: see above	@param basket2: see above

"""	"""

logging.info("CCCCC %s %s"%(basket1,basket2))	logging.info("CCCCC %s %s"%(basket1,basket2))

try:	try:
Line 854 class CDLIBasketContainer(OrderedFolder)	Line 918 class CDLIBasketContainer(OrderedFolder)
@param newbasket: name of the new basket	@param newbasket: name of the new basket
@param oldbaskets: list of baskets to be joined	@param oldbaskets: list of baskets to be joined
"""	"""
	if oldBaskets is None:
	return False, "No Baskets selected!"

try:	try:
newB=self.addBasket(newBasket)	newB=self.addBasket(newBasket)
except:	except:
return False, "cannot create the new basket"	return False, "cannot create the new basket"

newBasketContent={}	newBasketContent={}

for ob in oldBaskets:	for ob in oldBaskets:
x= getattr(self,ob,None)	x= getattr(self,ob,None)
if x is None:	if x is None:
Line 1022 class CDLIBasket(Folder,CatalogAware):	Line 1090 class CDLIBasket(Folder,CatalogAware):
return [x[1].getId() for x in self.getLastVersion().getContent()]	return [x[1].getId() for x in self.getLastVersion().getContent()]


def isActual(self,obj):	def isActual(self,obj,nummer):
	"""teste ob im basket die aktuelle version ist, obj kann entweder ein CDLIFile sein oder eine
	eine pnummer, die auf ein CDLIFile verweist"""
	try:
	#logging.debug("isActual:"+repr(obj))
	if isinstance(obj, CDLIFile):
	actualNo=obj.getLastVersion().getVersionNumber()
	else:
	actualNo=self.cdliRoot.getFileObjectLastVersion(obj).getVersionNumber()

	if actualNo==nummer:
	return True , 0
	else:
	return False, actualNo
	except:
	logging.error( """is actual: %s (%s %s)"""%(repr(obj),sys.exc_info()[0],sys.exc_info()[1]))
	logging.error(""" PARAMS: %s %s"""%(obj,nummer))
	return False, -1
	def isActualOld(self,obj):
"""teste ob im basket die aktuelle version ist"""	"""teste ob im basket die aktuelle version ist"""
	try:
	#logging.debug("isActual:"+repr(obj))
actualNo=obj[1].getLastVersion().getVersionNumber()	actualNo=obj[1].getLastVersion().getVersionNumber()
storedNo=obj[0].getVersionNumber()	storedNo=obj[0].getVersionNumber()

founds=self.CDLICatalog.search({'title':obj[0].getId()})
if len(founds)>0:
actualNo=founds[0].getObject().getLastVersion().getVersionNumber()

if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":	#actualNo=self.getFileObjectLastVersion(obj.getId()).getVersionNumber()
return False, -1
	#if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
	# return False, -1

if actualNo==storedNo:	if actualNo==storedNo:
return True , 0	return True , 0
else:	else:
return False, actualNo	return False, actualNo
	except:
	logging.error( """is actual: %s (%s %s)"""%(repr(obj),sys.exc_info()[0],sys.exc_info()[1]))

	return False, -1

def history(self):	def history(self):
"""history"""	"""history"""
Line 1185 class CDLIBasket(Folder,CatalogAware):	Line 1276 class CDLIBasket(Folder,CatalogAware):
def swap(x):	def swap(x):
return (x[1],x[0])	return (x[1],x[0])

	logging.info("add to basket (%s)"%(repr(ids)))
logging.info("add to basket (%s)"%(self.getId()))	logging.info("add to basket (%s)"%(self.getId()))
lastVersion=self.getLastVersion()	lastVersion=self.getLastVersion()

Line 1210 class CDLIBasket(Folder,CatalogAware):	Line 1302 class CDLIBasket(Folder,CatalogAware):
# newContent.append((found.getObject().getLastVersion(),found.getObject()))	# newContent.append((found.getObject().getLastVersion(),found.getObject()))
# added+=1	# added+=1

hash = md5.new(repr(self.makelist(ids))).digest() # erzeuge hash als identification	hash = md5.new(repr(makelist(ids))).hexdigest() # erzeuge hash als identification
#logging.debug("JJJJJJJ:"+repr(self.makelist(ids)))	#logging.debug("JJJJJJJ:"+repr(self.makelist(ids)))
logging.debug("JJJJJJJ:"+repr(hash))

if hasattr(self.cdliRoot,'_v_tmpStore') and self.cdliRoot._v_tmpStore.has_key(hash):
logging.debug("from store!")
newContent=Set(map(swap,self.cdliRoot._v_tmpStore[hash]))

	retrieved = self.CDLICache.retrieve(hash)
	if retrieved:
	newContent=Set(map(swap,retrieved))
else:	else:
logging.debug("not from store!")
newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])	newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])



	#remove all Elements which are not stored
	if (None,None) in newContent:
	newContent.remove((None,None))
content=Set(oldContent).union(newContent)	content=Set(oldContent).union(newContent)
added = len(content)-len(oldContent)	added = len(content)-len(oldContent)
if not username:	if not username:
Line 1242 class CDLIBasket(Folder,CatalogAware):	Line 1335 class CDLIBasket(Folder,CatalogAware):
ret=[]	ret=[]

lv=self.getLastVersion()	lv=self.getLastVersion()
for obj in lv.content.getContent():	#for obj in lv.content.getContent():
logging.info("XXXXXXXXXX %s"%repr(obj))	#logging.info("XXXXXXXXXX %s"%repr(obj))
ret.append((obj[1].getId(),obj[0].versionNumber))	# ret.append((obj[1].getId(),obj[0].versionNumber))

return ret	return lv

def getContentIds(self):	def getContentIds(self):
"""print basket content"""	"""print basket content"""
Line 1330 class CDLIBasketVersion(Implicit,Persist	Line 1423 class CDLIBasketVersion(Implicit,Persist

objs=self.getContent()	objs=self.getContent()
for obj in objs:	for obj in objs:
if not self.isActual(obj)[0]:	if not self.isActual(obj[0],obj[1])[0]:
return True	return True
return False	return False

Line 1357 class CDLIBasketVersion(Implicit,Persist	Line 1450 class CDLIBasketVersion(Implicit,Persist
return """I am sorry, currently the server has to many requests for downloads, please come back later!"""	return """I am sorry, currently the server has to many requests for downloads, please come back later!"""


if (check=="yes") and self.containsNonActualFiles():	#if (check=="yes") and self.containsNonActualFiles():
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)	# pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)
	#
	# return pt(lock=lock)

	# neue Version aus Performancegruenden, es wird nicht mehr getestet, ob es nicht aktuelle Objekte gibt
	# sondern lediglich gefragt.
	if (check=="yes"):
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_ask.zpt')).__of__(self)

return pt(lock=lock)	return pt(lock=lock)

Line 1366 class CDLIBasketVersion(Implicit,Persist	Line 1466 class CDLIBasketVersion(Implicit,Persist

return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")	return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")

def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no"):	def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no",repeat=None):
"""print do the download"""	"""print do the download"""


ret=""	ret=""
lockedObjects={}	lockedObjects={}

self.temp_folder.downloadCounterBaskets+=1
self._p_changed=1
transaction.get().commit()

if lock:

	if lock:
	logging.debug("------lock:"+repr(lock))
if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':	if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':
self.temp_folder.downloadCounterBaskets-=1
self._p_changed=1
transaction.get().commit()
self.temp_folder.downloadCounterBaskets-=1
self._p_changed=1
transaction.get().commit()
return "please login first"	return "please login first"

#check if a locked object exist in the basket.	#check if a locked object exist in the basket.
lockedObjects={}	lockedObjects={}
for object in self.content.getContent():	for object in self.content.getContent():
	obj=self.getFileObject(object[0])
if (not str(object[1].lockedBy)=="") and (not (str(object[1].lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):	if (not str(obj.lockedBy)=="") and (not (str(obj.lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):
lockedObjects[object[1].title]=repr(object[1].lockedBy)	lockedObjects[obj.title]=repr(obj.lockedBy)


keys=lockedObjects.keys()	keys=lockedObjects.keys()
Line 1402 class CDLIBasketVersion(Implicit,Persist	Line 1496 class CDLIBasketVersion(Implicit,Persist
self.REQUEST.SESSION['lockedObjects']=lockedObjects	self.REQUEST.SESSION['lockedObjects']=lockedObjects
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)

self.temp_folder.downloadCounterBaskets-=1
self._p_changed=1
transaction.get().commit()

return pt()	return pt()

Line 1414 class CDLIBasketVersion(Implicit,Persist	Line 1505 class CDLIBasketVersion(Implicit,Persist



	threadName=repeat
	if not threadName or threadName=="":
	thread=DownloadBasketFinallyThread()
	threadName=thread.getName()[0:]

	if (not hasattr(self,'_v_downloadBasket')):
	self._v_downloadBasket={}


	self._v_downloadBasket[threadName]=thread
	logging.debug("dwonloadfinally:"+repr(self))

	if isinstance(self,CDLIBasketVersion):
	obj=self
	else:
	obj=self.aq_parent
	logging.debug("dwonloadfinally2:"+repr(obj))
	logging.debug("dwonloadfinally2:"+repr(obj.aq_parent))

	obj2=obj.aq_parent
	if not isinstance(obj2,CDLIBasket):
	obj2=obj2.aq_parent

	basketID=obj2.getId()
	versionNumber=obj.getId()
	logging.debug("dwonloadfinally2:"+repr(basketID))
	logging.debug("dwonloadfinally2:"+repr(versionNumber))


	if lock:
	logging.debug("-----start locking")
for object in self.content.getContent():	for object in self.content.getContent():
logging.error("ret:"+repr(object[0]))	obj=self.ctx.getFileObject(object[0])
logging.error(" -"+repr(procedure))	if obj.lockedBy =='':
logging.error(" -"+repr(object[1].lockedBy))	obj.lockedBy=self.REQUEST['AUTHENTICATED_USER']
	logging.debug("-----finished locking")

if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):	#obj.lockedBy=user
logging.error("ret1")	self._v_downloadBasket[threadName].set(lock,procedure,self.REQUEST['AUTHENTICATED_USER'],current,basketID,versionNumber)
if current=="no": #version as they are in the basket
logging.error("ret2")	self._v_downloadBasket[threadName].start()
ret+=str(object[0].getData())+"\n"
elif current=="yes":
logging.error("ret3")
#search current object	wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
if len(founds)>0:	if wait_template:
ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"	return wait_template[0][1]()
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadBasketWait.zpt')).__of__(self)

	return pt(txt=self.absolute_url()+'/downloadObjectsAsOneFileFinally',threadName=threadName,
	counter=self._v_downloadBasket[threadName].getCounter(),
	number=self._v_downloadBasket[threadName].getNumberOfFiles())
	#_v_xmltrans.run()

	else:
	#recover thread, if lost
	if not hasattr(self,'_v_downloadBasket'):
	self._v_downloadBasket={}
	if not self._v_downloadBasket.get(threadName,None):
	for thread in threading.enumerate():
	if threadName == thread.getName():
	self._v_downloadBasket[threadName]=thread

	if self._v_downloadBasket.get(threadName,None) and (self._v_downloadBasket[threadName] is not None) and (not self._v_downloadBasket[threadName].end) :

	wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
	if wait_template:
	return wait_template[0][1]()

	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadBasketWait.zpt')).__of__(self)
	return pt(txt=self.absolute_url()+'/downloadObjectsAsOneFileFinally',threadName=threadName,
	counter=self._v_downloadBasket[threadName].getCounter(),
	number=self._v_downloadBasket[threadName].getNumberOfFiles())
	else:


	logging.debug("FINISHED")
	if not self._v_downloadBasket.get(threadName,None):
	for thread in threading.enumerate():
	if threadName == thread.getName():
	self._v_downloadBasket[threadName]=thread

	#files = self._v_downloadBasket[threadName].result
	# lade die files und die locked files, bei grossen Baskets muss u.U. gewartet werden
	# bis das Commit aus dem Thread alles geschrieben hat, in dem Falle existiert resultHash[threadName]
	# noch nicht.
	o1 = file("/tmp/"+threadName,'r')
	files=pickle.load(o1)
	os.remove("/tmp/"+threadName)
	o2 = file("/tmp/"+threadName+'_lockedFiles','r')

	lockedFiles=pickle.load(o2)
	os.remove("/tmp/"+threadName+'_lockedFiles')
	# try:
	# files=self.basketContainer.resultHash[threadName]
	# except:
	# i=0
	# while (not self.basketContainer.resultHash.has_key(threadName)) and (i<100):
	# logging.debug(" downloadFinally: I am waiting for thread %s to write the resultHashfile: %s"%(threadName,i))
	# time.sleep(5)
	# i+=1
	# files=self.basketContainer.resultHash[threadName]
	#
	# try:
	# lockedFiles=self.basketContainer.resultLockedHash[threadName]
	# except:
	# i=0
	# while (not self.basketContainer.resultLockedHash.has_key(threadName)) and (i<100):
	# logging.debug(" downloadFinally: I am waiting for thread %s to write the LockedHashfile: %s"%(threadName,i))
	# time.sleep(5)
	# i+=1
	# lockedFiles=self.basketContainer.resultLockedHash[threadName]

	# fh=file("/var/tmp/test")
	#ret =fh.read()

if lock and object[1].lockedBy=='':	if (not isinstance(self.aq_parent,CDLIBasket)):
object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']	basket_name=self.aq_parent.aq_parent.title+"_V"+self.getId()
	else:
basket_name=self.aq_parent.title+"_V"+self.getId()	basket_name=self.aq_parent.title+"_V"+self.getId()



#write basketname to header of atf file	#write basketname to header of atf file
ret="#basket: %s\n"%basket_name+ret

self.temp_folder.downloadCounterBaskets-=1
self._p_changed=1
transaction.get().commit()

self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)	self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")	self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
length=len(ret)	#length=len(ret)
self.REQUEST.RESPONSE.setHeader("Content-Length",length)	#self.REQUEST.RESPONSE.setHeader("Content-Length",length)

	ret="#basket: %s\n"%basket_name
self.REQUEST.RESPONSE.write(ret)	self.REQUEST.RESPONSE.write(ret)
return True
	for fileName in files:
	logging.debug("download: %s"%fileName)
	try:
	self.REQUEST.RESPONSE.write(file(fileName).read())
	except:
	logging.error("downloadasonefile: cannot read %s"%fileName)


	self.REQUEST.RESPONSE.write("\n# locked files\n")
	for fileName in lockedFiles:
	self.REQUEST.RESPONSE.write("# %s by %s\n"%fileName)

	self.REQUEST.RESPONSE.write("# locked files end\n")

	del self.basketContainer.resultHash[threadName]
	del self.basketContainer.resultLockedHash[threadName]

def numberOfItems(self):	def numberOfItems(self):
"""return anzahl der elemente im basket"""	"""return anzahl der elemente im basket"""
Line 1467 class CDLIBasketVersion(Implicit,Persist	Line 1675 class CDLIBasketVersion(Implicit,Persist

def getContent(self):	def getContent(self):
"""get Basket Content"""	"""get Basket Content"""
return self.content.getContent()	logging.debug("retrieving content A")
	cnt = self.content
	logging.debug("retrieving content: obj %s"%cnt)
	tmp = self.content.getContent()
	logging.debug("got content")
	return tmp


def __init__(self,id,user,comment="",basketContent=[]):	def __init__(self,id,user,comment="",basketContent=[]):
Line 1490 class CDLIBasketVersion(Implicit,Persist	Line 1703 class CDLIBasketVersion(Implicit,Persist
security.declareProtected('manage','index_html')	security.declareProtected('manage','index_html')
def index_html(self):	def index_html(self):
"""view the basket"""	"""view the basket"""
	logging.debug("start index_html - Basket version")
if self.REQUEST.get('change',False):	if self.REQUEST.get('change',False):
ob=self.aq_parent.updateObjects(self.REQUEST['change'])	ob=self.aq_parent.updateObjects(self.REQUEST['change'])

self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket	self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket
	logging.debug("start index_html - Basket version:template")
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','BasketVersionMain.zpt')).__of__(self)
return pt()	return pt()

def getObjUrl(self,result):	def getObjUrl(self,result):
"""getUrl of the version of the object"""	"""getUrl of the version of the object"""
objId=result[1].getTitle()
founds=self.CDLICatalog.search({'title':objId})	founds=self.CDLICatalog.search({'title':result})
if len(founds)>0:	if len(founds)>0:
return founds[0].getObject().getLastVersion().absolute_url()	return founds[0].getObject().getLastVersion().absolute_url()

else: #assume version number	else: #assume version number
splitted=objId.split("_")	splitted=result.split("_")
founds=self.CDLICatalog.search({'title':splitted[1]})	founds=self.CDLICatalog.search({'title':splitted[1]})
return founds[0].getObject().getLastVersion().absolute_url()+'/'+objId	return founds[0].getObject().getLastVersion().absolute_url()+'/'+result

def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):	def manage_addCDLIBasketVersion(self,user,comment="",basketContent=[],RESPONSE=None):
"""add a version"""	"""add a version"""
Line 1551 class CDLIFileObject(CatalogAware,extVer	Line 1764 class CDLIFileObject(CatalogAware,extVer
"""Return cataloguable key for ourselves."""	"""Return cataloguable key for ourselves."""
return str(self)	return str(self)

	def setAuthor(self, author):
	"""change the author"""
	self.author = author

def makeThisVersionCurrent_html(self):	def makeThisVersionCurrent_html(self):
"""form for making this version current"""	"""form for mthis version current"""

pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
return pt()	return pt()
Line 1645 def manage_addCDLIFileObject(self,id,vC=	Line 1862 def manage_addCDLIFileObject(self,id,vC=
logging.debug("reindex2: %s in %s"%(repr(fob), repr(fob.default_catalog)))	logging.debug("reindex2: %s in %s"%(repr(fob), repr(fob.default_catalog)))
fob.index_object()	fob.index_object()

	self.CDLIRoot.updateOrAddToFileBTree(ob)
if REQUEST is not None:	if REQUEST is not None:
REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')	REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')

Line 1758 class CDLIFile(extVersionedFile,CatalogA	Line 1976 class CDLIFile(extVersionedFile,CatalogA
except:	except:
pass	pass

	#self.cdliRoot.updateOrAddToFileBTree(self)# now update the object in the cache


if RESPONSE:	if RESPONSE:
if ob.getSize()==0:	if ob.getSize()==0:
self.REQUEST.SESSION['objID']=ob.getId()	self.REQUEST.SESSION['objID']=ob.getId()
Line 1967 class CDLIFileFolder(extVersionedFileFol	Line 2188 class CDLIFileFolder(extVersionedFileFol
fileTree.add(found.getId)	fileTree.add(found.getId)
logging.debug("ADDD:"+found.getId)	logging.debug("ADDD:"+found.getId)

def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None,REQUEST=None):	def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None,REQUEST=None,returnHash=False,hash=None):
"""findObjectsFromList (, TAB oder LINE separated)"""	"""findObjectsFromList (, TAB oder LINE separated)"""

logging.debug("start: findObjectsFromList")	logging.debug("start: findObjectsFromList")
	#logging.debug("start: findObjectsFromList"+repr(list))


if upload: # list from file upload	if upload: # list from file upload
txt=upload.read()	txt=upload.read()

Line 2001 class CDLIFileFolder(extVersionedFileFol	Line 2225 class CDLIFileFolder(extVersionedFileFol
pt=getattr(self,'filelist.html')	pt=getattr(self,'filelist.html')
return pt(basketName=basketName,numberOfObjects=numberOfObjects)	return pt(basketName=basketName,numberOfObjects=numberOfObjects)


	result =self.CDLICache.retrieve(hash)
	if result:
	logging.debug("give result from storage2")
	return hash,result

if list is not None: # got already a list	if list is not None: # got already a list

logging.debug(" ----List version")	logging.debug(" ----List version")
Line 2024 class CDLIFileFolder(extVersionedFileFol	Line 2254 class CDLIFileFolder(extVersionedFileFol


ids = fileTree & self.v_file_ids	ids = fileTree & self.v_file_ids
	#self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
	l=makelist(fileTree)[0:]
	#logging.debug("l-list:"+repr(l))
	self.REQUEST.SESSION['fileIds']=l#store fieldIds in session for further usage
	self.REQUEST.SESSION['searchList']=l
	#self.REQUEST.SESSION['searchList']=['P000001.atf']


hash = md5.new(repr(self.makelist(ids))).digest() # erzeuge hash als identification	hash = md5.new(repr(makelist(fileTree))).hexdigest() # erzeuge hash als identification
#TODO: do I need garbage collection for _v_tmpStore ?	self.REQUEST.SESSION['hash']=hash
#logging.debug("list:"+repr(self.makelist(ids)))	#TODO: do I need garbage collection for v_tmpStore ?

#logging.debug("Hash:"+repr(hash))	#logging.debug("Hash:"+repr(hash))
if hasattr(self.cdliRoot,'_v_tmpStore') and self.cdliRoot._v_tmpStore.has_key(hash):	#
logging.debug("asking for storage")	# if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash):
return self.cdliRoot._v_tmpStore[hash]	# logging.debug("asking for storage")
	# res=self.cdliRoot.v_tmpStore[hash]
	# if res:
	# if returnHash == True:
	# return hash,res
	# return res

#TODO: get rid of one of these..	#TODO: get rid of one of these..
#ids=[x.getObject().getId() for x in ret]	#ids=[x.getObject().getId() for x in ret]
Line 2040 class CDLIFileFolder(extVersionedFileFol	Line 2282 class CDLIFileFolder(extVersionedFileFol

#self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage	#self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
#self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']	#self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']

if display:	if display:
pt=getattr(self,'filelist.html')	pt=getattr(self,'filelist.html')
Line 2049 class CDLIFileFolder(extVersionedFileFol	Line 2289 class CDLIFileFolder(extVersionedFileFol
return pt(search=ids)	return pt(search=ids)
else:	else:
#self.REQUEST.SESSION['hash'] = ret # store in session	#self.REQUEST.SESSION['hash'] = ret # store in session
if not hasattr(self,'_v_tmpStore'):
self.cdliRoot._v_tmpStore={}
#logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))	#logging.debug("HHHHHHNEU:"+repr(self.makelist(ids)))
#logging.debug("HHHHHHNEU:"+repr(hash))	#logging.debug("HHHHHHNEU:"+repr(hash))
self.cdliRoot._v_tmpStore[hash] = ret # store in session	self.CDLICache.store(hash,ret)

	if returnHash == True:
	return hash,ret
return ret	return ret


Line 2061 class CDLIFileFolder(extVersionedFileFol	Line 2303 class CDLIFileFolder(extVersionedFileFol
if start:	if start:
RESPONSE.redirect("filelist.html?start:int="+str(start))	RESPONSE.redirect("filelist.html?start:int="+str(start))

def makelist(self,mySet):
x = list(mySet)
x.sort()
return x

security.declareProtected('Manage','createAllFilesAsSingleFile')	security.declareProtected('Manage','createAllFilesAsSingleFile')
def createAllFilesAsSingleFile(self,RESPONSE=None):	def createAllFilesAsSingleFile(self,RESPONSE=None):
"""download all files"""	"""download all files"""
Line 2193 class CDLIRoot(Folder):	Line 2430 class CDLIRoot(Folder):
'graphemes':cdliSplitter.graphemeSplitter()}	'graphemes':cdliSplitter.graphemeSplitter()}


	def unicodify(self,txt):
	return unicodify(txt)
	def invalidateOldCacheVersion(self):
	"""loescht die alte Version des Cache"""
	del self.v_tmpStore
	return "done"

	def viewATF(self,id,RESPONSE):
	"""view an Object"""
	ob = self.CDLICatalog({'title':id})
	logging.debug(ob[0].getObject().getLastVersion().absolute_url()+"/view")
	if len(ob)>0:
	RESPONSE.redirect(ob[0].getObject().getLastVersion().absolute_url()+"/view")
	return "not found"

	def history(self,id,RESPONSE):
	"""view an Object"""
	ob = self.CDLICatalog({'title':id})
	if len(ob)>0:
	RESPONSE.redirect(ob[0].absolute_url+"/history")
	return "not found"


	def downloadLocked(self,id,RESPONSE):
	"""view an Object"""
	ob = self.CDLICatalog({'title':id})
	if len(ob)>0:
	RESPONSE.redirect(ob[0].absolute_url+"/downloadLocked")
	return "not found"

	def download(self,id,RESPONSE):
	"""view an Object"""
	ob = self.CDLICatalog({'title':id})
	if len(ob)>0:
	RESPONSE.redirect(ob[0].getLastVersion().absolute_url())
	return "not found"
	def addCDLIFileObjectForm(self,id,RESPONSE):
	"""view an Object"""
	ob = self.CDLICatalog({'title':id})
	if len(ob)>0:
	RESPONSE.redirect(ob[0].absolute_url+"/addCDLIFileObjectForm")
	return "not found"

	def addVersionedFileObjectForm(self,id,RESPONSE):
	"""view an Object"""
	ob = self.CDLICatalog({'title':id})
	if len(ob)>0:
	RESPONSE.redirect(ob[0].absolute_url+"/addVersionedFileObjectForm")
	return "not found"

	def unlock(self,id,RESPONSE):
	"""view an Object"""
	ob = self.CDLICatalog({'title':id})
	if len(ob)>0:
	RESPONSE.redirect(ob[0].absolute_url+"/unlock")
	return "not found"

def getFileObject(self,fileId):	def getFileObject(self,fileId):
	"""get an object"""
x=self.v_files.get(fileId)	x=self.v_files.get(fileId)
#logging.debug(x)	#logging.debug(x)
return x	return x

def getFileObjectLastVersion(self,fileId):	def getFileObjectLastVersion(self,fileId):
	"""get an object"""
x=self.v_files_lastVersion.get(fileId)	x=self.v_files_lastVersion.get(fileId)
#logging.debug(x)	#logging.debug("lastVersion: "+repr(x))
return x	return x

	def showFileIds(self):
	"""showIds"""
	return self.v_file_ids

def generateFileBTree(self):	def generateFileBTree(self):
"""erzeuge einen Btree aus allen Files"""	"""erzeuge einen Btree aus allen Files"""
self.v_files = OOBTree()	self.v_files = OOBTree()
Line 2216 class CDLIRoot(Folder):	Line 2516 class CDLIRoot(Folder):
self.v_file_ids.add(x.getId)	self.v_file_ids.add(x.getId)
logging.debug("add:"+x.getId+"XXX"+repr(x.getObject()))	logging.debug("add:"+x.getId+"XXX"+repr(x.getObject()))

return "done"	return True


	def updateOrAddToFileBTree(self,obj):
	"""update a BTree"""
	self.v_files.update({obj.getId():obj})
	self.v_files_lastVersion.update({obj.getId():obj.getLastVersion()})

	self.v_file_ids.add(obj.getId())
	logging.debug("update:"+obj.getId()+"XXX"+repr(obj))

	def deleteFromBTree(self,objId):
	"""delete an obj"""
	self.v_files.pop(objId)
	self.v_files_lastVersion.pop(objId)
	self.v_file_ids.remove(objId)



def deleteFiles(self,ids):	def deleteFiles(self,ids):
"""delete files"""	"""delete files"""
for id in ids:	for id in ids:
Line 2474 class CDLIRoot(Folder):	Line 2792 class CDLIRoot(Folder):

return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)	return """ 2;url=%s?repeat=%s """%(self.absolute_url()+txt,threadName)

	def refreshTxtBasket(self,txt="",threadName=None):
	"""txt fuer refresh"""

	return """ 2;url=%s?repeat=%s """%(txt,threadName)


def getResult(self,threadName=None):	def getResult(self,threadName=None):
"""result of thread"""	"""result of thread"""
Line 2650 class CDLIRoot(Folder):	Line 2973 class CDLIRoot(Folder):
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
return pt(txt='/uploadATFfinally',threadName=threadName)	return pt(txt='/uploadATFfinally',threadName=threadName)
else:	else:


	idTmp=self.REQUEST.SESSION['idTmp']
	stObj=getattr(self.temp_folder,idTmp)
self.REQUEST.SESSION['idTmp']=None	self.REQUEST.SESSION['idTmp']=None

	#update changed
	logging.debug("dir:"+repr(stObj.returnValue['changed']))
	for x in stObj.returnValue['changed']:
	ob=self.CDLICatalog.search({'title':x[0]})

	self.cdliRoot.updateOrAddToFileBTree(ob[0].getObject())
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect(self.absolute_url())	RESPONSE.redirect(self.absolute_url())

Line 2665 class CDLIRoot(Folder):	Line 2999 class CDLIRoot(Folder):
for f in files:	for f in files:
folder=f[0:3]	folder=f[0:3]
f2=f[0:5]	f2=f[0:5]

	#check if main folder PXX already exists
obj=self.ZopeFind(root,obj_ids=[folder])	obj=self.ZopeFind(root,obj_ids=[folder])
logging.debug("importFiles: folder=%s f2=%s obj=%s"%(folder,f2,obj))	logging.debug("importFiles: folder=%s f2=%s obj=%s"%(folder,f2,obj))
if ext:	if ext:
ext.result="<p>adding: %s </p>"%f+ext.result	ext.result="<p>adding: %s </p>"%f+ext.result

if not obj:
	if not obj: # if not create it
manage_addCDLIFileFolder(root,folder,folder)	manage_addCDLIFileFolder(root,folder,folder)
fobj=getattr(root,folder)	fobj=getattr(root,folder)
#transaction.get().commit()	#transaction.get().commit()
Line 2678 class CDLIRoot(Folder):	Line 3015 class CDLIRoot(Folder):
else:	else:
fobj=obj[0][1]	fobj=obj[0][1]

	#check IF PYYYYY already exist
obj2=fobj.ZopeFind(fobj,obj_ids=[f2])	obj2=fobj.ZopeFind(fobj,obj_ids=[f2])
logging.debug("importFiles: fobj=%s obj2=%s"%(fobj,obj2))	logging.debug("importFiles: fobj=%s obj2=%s"%(fobj,obj2))

if not obj2:	if not obj2:# if not create it
manage_addCDLIFileFolder(fobj,f2,f2)	manage_addCDLIFileFolder(fobj,f2,f2)
fobj2=getattr(fobj,f2)	fobj2=getattr(fobj,f2)

else:	else:
fobj2=obj2[0][1]	fobj2=obj2[0][1]

	# not add the file
file2=os.path.join(folderName,f)	file2=os.path.join(folderName,f)
id=f	id=f
logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))	logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))
fobj2.addFile(vC='',file=file(file2),author=author,newName=f)	fobj2.addFile(vC='',file=file(file2),author=author,newName=f)
count+=1	count+=1

	#now add the file to the storage
	ob = getattr(fobj2,f)
	self.cdliRoot.updateOrAddToFileBTree(ob)

if count%100==0:	if count%100==0:
logging.debug("importfiles: committing")	logging.debug("importfiles: committing")
transaction.get().commit()	transaction.get().commit()

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

Removed from v.1.84
changed lines
	Added in v.1.103