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.83 and 1.93

version 1.83, 2008/09/25 12:37:54	version 1.93, 2008/10/07 06:53:57
Line 31 from BTrees.IOBTree import IOBTree	Line 31 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

	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 395 class uploadATFfinallyThread(Thread):	Line 401 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 633 class CDLIBasketContainer(OrderedFolder)	Line 640 class CDLIBasketContainer(OrderedFolder)
ret+=str(object[0].getData())+"\n"	ret+=str(object[0].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]})	founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
if len(founds)>0:	if len(founds)>0:
ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"	ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
Line 1024 class CDLIBasket(Folder,CatalogAware):	Line 1031 class CDLIBasket(Folder,CatalogAware):

def isActual(self,obj):	def isActual(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 1210 class CDLIBasket(Folder,CatalogAware):	Line 1222 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):
	if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key("hash"):
logging.debug("from store!")	logging.debug("from store!")
newContent=Set(map(swap,self.cdliRoot._v_tmpStore[hash]))	newContent=Set(map(swap,self.cdliRoot.v_tmpStore[hash]))

else:	else:
logging.debug("not from store!")	logging.debug("not from store!")
Line 1243 class CDLIBasket(Folder,CatalogAware):	Line 1255 class CDLIBasket(Folder,CatalogAware):

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 ret
Line 1366 class CDLIBasketVersion(Implicit,Persist	Line 1378 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.
Line 1402 class CDLIBasketVersion(Implicit,Persist	Line 1408 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 1417 class CDLIBasketVersion(Implicit,Persist



for object in self.content.getContent():	threadName=repeat
logging.error("ret:"+repr(object[0]))	if not threadName or threadName=="":
logging.error(" -"+repr(procedure))	thread=DownloadBasketFinallyThread()
logging.error(" -"+repr(object[1].lockedBy))	threadName=thread.getName()[0:]

if (procedure=="downloadAll") or (object[1].lockedBy=='') or (object[1].lockedBy==self.REQUEST['AUTHENTICATED_USER']):	if (not hasattr(self,'_v_downloadBasket')):
logging.error("ret1")	self._v_downloadBasket={}
if current=="no": #version as they are in the basket
logging.error("ret2")
ret+=str(object[0].getData())+"\n"
elif current=="yes":
logging.error("ret3")
#search current object
founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
if len(founds)>0:
ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"

if lock and object[1].lockedBy=='':
	self._v_downloadBasket[threadName]=thread
	logging.debug("dwonloadfinally:"+repr(self))
	basketID=self.aq_parent.aq_parent.getId()
	versionNumber=self.aq_parent.getId()

	if lock:
	logging.debug("-----start locking")
	for object in self.content.getContent():
	if object[1].lockedBy =='':
object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']	object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
	logging.debug("-----finished locking")

	#obj.lockedBy=user
	self._v_downloadBasket[threadName].set(lock,procedure,self.REQUEST['AUTHENTICATED_USER'],current,basketID,versionNumber)

	self._v_downloadBasket[threadName].start()



	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())
	#_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
	files=self.basketContainer.resultHash[threadName]
	lockedFiles=self.basketContainer.resultLockedHash[threadName]

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

	if (not isinstance(self.aq_parent,CDLIBasket)):
	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:
	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 1551 class CDLIFileObject(CatalogAware,extVer	Line 1627 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 1725 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 1839 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 2051 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 2088 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)

	if hash is not None and hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key(hash):

	logging.debug("asking for storage2")
	result =self.cdliRoot.v_tmpStore[hash]
	if result:
	logging.debug("give result from storage2")
	return hash,self.cdliRoot.v_tmpStore[hash]

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 2119 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(makelist(fileTree))).hexdigest() # erzeuge hash als identification
	self.REQUEST.SESSION['hash']=hash
	#TODO: do I need garbage collection for v_tmpStore ?

hash = md5.new(repr(self.makelist(ids))).digest() # erzeuge hash als identification	#logging.debug("Hash:"+repr(hash))
#TODO: do I need garbage collection for _v_tmpStore ?	#
if hasattr(self.cdliRoot,'_v_tmpStore') and self.cdliRoot._v_tmpStore.has_key(hash):	# 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]
ret=[(self.getFileObject(x),self.getFileObjectLastVersion(x)) for x in ids]	ret=[(self.getFileObject(x),self.getFileObjectLastVersion(x)) for x in ids]
self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']	#self.REQUEST.SESSION['fileIds']=ids#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 2043 class CDLIFileFolder(extVersionedFileFol	Line 2154 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'):	if not hasattr(self,'v_tmpStore'):
self.cdliRoot._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.cdliRoot.v_tmpStore[hash] = ret # store in session
	if returnHash == True:
	return hash,ret
return ret	return ret


Line 2055 class CDLIFileFolder(extVersionedFileFol	Line 2168 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 2187 class CDLIRoot(Folder):	Line 2295 class CDLIRoot(Folder):
'graphemes':cdliSplitter.graphemeSplitter()}	'graphemes':cdliSplitter.graphemeSplitter()}


	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)	l#ogging.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 2210 class CDLIRoot(Folder):	Line 2374 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 2468 class CDLIRoot(Folder):	Line 2650 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 2644 class CDLIRoot(Folder):	Line 2831 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 2659 class CDLIRoot(Folder):	Line 2857 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 2672 class CDLIRoot(Folder):	Line 2873 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.83
changed lines
	Added in v.1.93