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.80.2.19 and 1.99

version 1.80.2.19, 2008/01/21 17:06:21	version 1.99, 2008/10/15 07:48:05
Line 21 from ZPublisher.HTTPRequest import HTTPR	Line 21 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	from BTrees.OOBTree import OOBTree, OOTreeSet
import logging	import logging
import transaction	import transaction
import copy	import copy
import codecs	import codecs
import sys	import sys
	from BTrees.IOBTree import IOBTree
import cdliSplitter	import cdliSplitter
	from sets import Set
	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 221 class BasketContent(SimpleItem):	Line 228 class BasketContent(SimpleItem):
"""content"""	"""content"""
self.contentList=content[0:]	self.contentList=content[0:]

def getContent(self):	def getContent(self,filtered=True):
"""get content"""	"""get content"""
	ret=[]
	if filtered:
	for x in self.contentList:
	if not((x[0] is None) or (x[1] is None)):
	ret.append(x)
	return ret

	else:
return self.contentList	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:]	self.contentList=content[0:]

Line 394 class uploadATFfinallyThread(Thread):	Line 412 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 632 class CDLIBasketContainer(OrderedFolder)	Line 651 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 651 class CDLIBasketContainer(OrderedFolder)	Line 670 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 662 class CDLIBasketContainer(OrderedFolder)	Line 685 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 813 class CDLIBasketContainer(OrderedFolder)	Line 847 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 853 class CDLIBasketContainer(OrderedFolder)	Line 888 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 925 class CDLIBasketContainer(OrderedFolder)	Line 964 class CDLIBasketContainer(OrderedFolder)
if not ids:	if not ids:
ids=self.REQUEST.SESSION['fileIds']	ids=self.REQUEST.SESSION['fileIds']

if type(ids) is not ListType:	if (type(ids) is not ListType) and (not isinstance(ids,Set)):
ids=[ids]	ids=[ids]

	if isinstance(ids,Set):
	ids=list(ids)

if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):	if (submit.lower()=="store in new basket") or (submit.lower()=="new basket"):
basketRet=self.addBasket(newBasketName)	basketRet=self.addBasket(newBasketName)
self.setActiveBasket(basketRet.getId())	self.setActiveBasket(basketRet.getId())
Line 941 class CDLIBasketContainer(OrderedFolder)	Line 983 class CDLIBasketContainer(OrderedFolder)

if fromFileList:	if fromFileList:

return self.cdli_main.findObjectsFromList(list=self.REQUEST.SESSION['fileIds'],basketName=basket.title,numberOfObjects=added)	return self.cdli_main.findObjectsFromList(list=ids,basketName=basket.title,numberOfObjects=added)

if RESPONSE:	if RESPONSE:

Line 1020 class CDLIBasket(Folder,CatalogAware):	Line 1062 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 1177 class CDLIBasket(Folder,CatalogAware):	Line 1224 class CDLIBasket(Folder,CatalogAware):

def addObjects(self,ids,deleteOld=None,username=None):	def addObjects(self,ids,deleteOld=None,username=None):
"""generate a new version of the basket with objects added"""	"""generate a new version of the basket with objects added"""

	def swap(x):
	return (x[1],x[0])

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

Line 1188 class CDLIBasket(Folder,CatalogAware):	Line 1239 class CDLIBasket(Folder,CatalogAware):
if deleteOld:	if deleteOld:
oldContent=[]	oldContent=[]

newContent=[]
added=0	added=0
for id in ids:	# for id in ids:
try:	# logging.debug("adding:"+id)
founds=self.CDLICatalog.search({'title':id})	# try:
except:	# founds=self.CDLICatalog.search({'title':id})
founds=[]	# except:
	# founds=[]
	#
	# for found in founds:
	# if found.getObject() not in oldContent:
	# #TODO: was passiert wenn, man eine Object dazuf�gt, das schon da ist aber eine neuere version
	# newContent.append((found.getObject().getLastVersion(),found.getObject()))
	# added+=1

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


	if hasattr(self.cdliRoot,'v_tmpStore') and self.cdliRoot.v_tmpStore.has_key("hash"): #TODO: muss eigentlich self.cdliRoot.v_tmpStore.has_key(hash): heissen (ohne "), erstmal so gesetzt damit der hash hier nie benutzt wird
	logging.debug("from store!")
	newContent=Set(map(swap,self.cdliRoot.v_tmpStore[hash]))

for found in founds:	else:
if found.getObject() not in oldContent:	logging.debug("not from store!")
#TODO: was passiert wenn, man eine Object dazuf�gt, das schon da ist aber eine neuere version	newContent=Set([(self.getFileObjectLastVersion(x),self.getFileObject(x)) for x in ids])
newContent.append((found.getObject().getLastVersion(),found.getObject()))
added+=1

content=oldContent+newContent
	content=Set(oldContent).union(newContent)
	added = len(content)-len(oldContent)
if not username:	if not username:
user=self.getActualUserName()	user=self.getActualUserName()
else:	else:
user = username	user = username

ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)	#logging.debug("content:"+repr(list(content)))
	ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=list(content))
logging.info("add to basket (%s) done"%(self.getId()))	logging.info("add to basket (%s) done"%(self.getId()))
return added	return added

Line 1220 class CDLIBasket(Folder,CatalogAware):	Line 1286 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 1343 class CDLIBasketVersion(Implicit,Persist	Line 1409 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 1379 class CDLIBasketVersion(Implicit,Persist	Line 1439 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 1391 class CDLIBasketVersion(Implicit,Persist	Line 1448 class CDLIBasketVersion(Implicit,Persist



for object in self.content.getContent():	threadName=repeat
	if not threadName or threadName=="":
	thread=DownloadBasketFinallyThread()
	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')):
if current=="no": #version as they are in the basket	self._v_downloadBasket={}
ret+=str(object[0].getData())+"\n"
elif current=="yes":
#search current object	self._v_downloadBasket[threadName]=thread
founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})	logging.debug("dwonloadfinally:"+repr(self))
if len(founds)>0:
ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"	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 and object[1].lockedBy=='':
	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 1522 class CDLIFileObject(CatalogAware,extVer	Line 1673 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 1616 def manage_addCDLIFileObject(self,id,vC=	Line 1771 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 1729 class CDLIFile(extVersionedFile,CatalogA	Line 1885 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 1931 class CDLIFileFolder(extVersionedFileFol	Line 2090 class CDLIFileFolder(extVersionedFileFol

return ret	return ret

def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):	def expandFile(self,fileId,fileTree):
	"""wildcard in fileID suche alle Treffer"""
	founds=self.CDLICatalog({'title':fileId})
	for found in founds:
	fileTree.add(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,returnHash=False,hash=None):
"""findObjectsFromList (, TAB oder LINE separated)"""	"""findObjectsFromList (, TAB oder LINE separated)"""

	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 1965 class CDLIFileFolder(extVersionedFileFol	Line 2134 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")
ret=[]	ret=[]
	fileTree=Set()

for fileId in list:	for fileId in list:
if fileId.find("*"): #check for wildcards
fileId=fileId	if fileId.find("*")>-1: #check for wildcards
	self.expandFile(fileId,fileTree)

elif len(fileId.split("."))==1:	elif len(fileId.split("."))==1:
fileId=fileId+".atf"	fileId=fileId+".atf"
	fileTree.add(fileId)
	#logging.debug(" -----:"+fileId)
	#ret+=self.CDLICatalog({'title':fileId})
	#x =self.getFileObject(fileId)
	#if x is not None:
	# ret.append(x)



	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 ?

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

ret+=self.CDLICatalog({'title':fileId})
#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]
self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage	ret=[(self.getFileObject(x),self.getFileObjectLastVersion(x)) for x in ids]
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')

return pt(search=ids)	return pt(search=ids)
else:	else:
	#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(hash))
	self.cdliRoot.v_tmpStore[hash] = ret # store in session
	if returnHash == True:
	return hash,ret
return ret	return ret


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


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 2119 class CDLIRoot(Folder):	Line 2341 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):
	"""get an object"""
	x=self.v_files.get(fileId)
	#logging.debug(x)
	return x

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

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

	def generateFileBTree(self):
	"""erzeuge einen Btree aus allen Files"""
	self.v_files = OOBTree()
	self.v_files_lastVersion = OOBTree()
	self.v_file_ids = Set()

	for x in self.CDLICatalog.searchResults():

	self.v_files.update({x.getId:x.getObject()})
	self.v_files_lastVersion.update({x.getId:x.getObject().getLastVersion()})
	self.v_file_ids.add(x.getId)
	logging.debug("add:"+x.getId+"XXX"+repr(x.getObject()))

	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 2157 class CDLIRoot(Folder):	Line 2477 class CDLIRoot(Folder):
return f[0].getObject().getData()	return f[0].getObject().getData()



def showFile(self,fileId,wholePage=False):	def showFile(self,fileId,wholePage=False):
"""show a file	"""show a file
@param fileId: P-Number of the document to be displayed	@param fileId: P-Number of the document to be displayed
Line 2296 class CDLIRoot(Folder):	Line 2615 class CDLIRoot(Folder):
return dict([(id,self.tagWordInFile(id, word, indexName, regExp)) for id in fileIds])	return dict([(id,self.tagWordInFile(id, word, indexName, regExp)) for id in fileIds])


	def getFileVersionList(self, pnum):
	"""get the version history as a list for the translit file with the given pnum"""
	f = getattr(self, self.file_catalog).search({'textid':pnum})
	if not f:
	return []

	return f[0].getObject().getVersionList()


def URLquote(self,str):	def URLquote(self,str):
"""quote url"""	"""quote url"""
return urllib.quote(str)	return urllib.quote(str)
Line 2368 class CDLIRoot(Folder):	Line 2696 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 2544 class CDLIRoot(Folder):	Line 2877 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 2559 class CDLIRoot(Folder):	Line 2903 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 2572 class CDLIRoot(Folder):	Line 2919 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.80.2.19
changed lines
	Added in v.1.99