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.8 and 1.91

version 1.80.2.8, 2007/11/27 10:12:58	version 1.91, 2008/10/06 12:57:12
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 99 def formatAtfFullLineNum(txt, nolemma=Tr	Line 106 def formatAtfFullLineNum(txt, nolemma=Tr
ret = []	ret = []
surf = ""	surf = ""
col = ""	col = ""
for line in txt.split("\n"):	for line in txt.splitlines():
line = unicodify(line)	line = unicodify(line)
if line and line[0] == '@':	if line and line[0] == '@':
# surface or column	# surface or column
Line 108 def formatAtfFullLineNum(txt, nolemma=Tr	Line 115 def formatAtfFullLineNum(txt, nolemma=Tr
surf = line.replace(words[0],surfaces[words[0]]).strip()	surf = line.replace(words[0],surfaces[words[0]]).strip()

elif words[0] == '@column':	elif words[0] == '@column':
col = words[1]	col = ' '.join(words[1:])

elif line and line[0] in '123456789':	elif line and line[0] in '123456789':
# ordinary line -> add line number	# ordinary line -> add line number
Line 144 def generateXMLReturn(hash):	Line 151 def generateXMLReturn(hash):
return ret	return ret










def unique(s):	def unique(s):
"""Return a list of the elements in s, but without duplicates.	"""Return a list of the elements in s, but without duplicates.

Line 321 class uploadATFfinallyThread(Thread):	Line 320 class uploadATFfinallyThread(Thread):
self.result+="<h2>Start processing</h2>"	self.result+="<h2>Start processing</h2>"

#shall I only upload the changed files?	#shall I only upload the changed files?
logging.info("uploadATFfinally procedure: %s"%procedure)	logging.debug("uploadATFfinally procedure: %s"%procedure)
if procedure=="uploadchanged":	if procedure=="uploadchanged":
changed=[x[0] for x in SESSION.get('changed',[])]	changed=[x[0] for x in SESSION.get('changed',[])]
uploadFns=changed+SESSION.get('newPs',[])	uploadFns=changed+SESSION.get('newPs',[])
Line 342 class uploadATFfinallyThread(Thread):	Line 341 class uploadATFfinallyThread(Thread):
#do first the changed files	#do first the changed files
i=0	i=0
for fn in uploadFns:	for fn in uploadFns:
	logging.debug("uploadATFfinally uploadFn=%s"%fn)
i+=1	i+=1
founds=ctx2.CDLICatalog.search({'title':fn})	founds=ctx2.CDLICatalog.search({'title':fn})
if len(founds)>0:	if len(founds)>0:
SESSION['author']=str(username)	SESSION['author']=str(username)
self.result="<p>Changing : %s"%fn+self.result	self.result="<p>Changing : %s"%fn+self.result
	logging.debug("uploadatffinallythread changing:%s"%fn+self.result)
founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)	founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)
if i==200:	if i%200==0:
i=0
transaction.get().commit()	transaction.get().commit()
logging.info("changing: do commit")	logging.debug("uploadatffinallythread changing: do commit")

transaction.get().commit()	transaction.get().commit()
logging.info("changing: last commit")	logging.debug("uploadatffinallythread changing: last commit")

#now add the new files	#now add the new files
newPs=SESSION['newPs']	newPs=SESSION['newPs']
if len(newPs)>0:	if len(newPs)>0:
tmpDir=SESSION['tmpdir']	tmpDir=SESSION['tmpdir']
logging.info("adding start")	logging.debug("uploadatffinallythread adding start")
self.result="<p>Adding files</p>"+self.result	self.result="<p>Adding files</p>"+self.result
#TODO: make this configurable, at the moment base folder for the files has to be cdli_main	#TODO: make this configurable, at the moment base folder for the files has to be cdli_main

ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)	ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
logging.info("adding finished")	logging.debug("uploadatffinallythread adding finished")


#unlock locked files?	#unlock locked files?
if unlock:	if unlock:
logging.info("unlocking start")	logging.debug("uploadatffinallythread unlocking start")
self.result="<p>Unlock files</p>"+self.result	self.result="<p>Unlock files</p>"+self.result
unlockFns=[]	unlockFns=[]
for x in os.listdir(SESSION['tmpdir']):	for x in os.listdir(SESSION['tmpdir']):
if not x in SESSION['errors']:	if not x in SESSION['errors']:
unlockFns.append(x)	unlockFns.append(x)
logging.info("unlocking have now what to unlock")
	logging.debug("unlocking have now what to unlock")

for fn in unlockFns:	for fn in unlockFns:
#logging.info("will unlock: %s"%fn)	#logging.info("will unlock: %s"%fn)
Line 385 class uploadATFfinallyThread(Thread):	Line 384 class uploadATFfinallyThread(Thread):
if len(founds)>0:	if len(founds)>0:
#logging.info("unlock: %s"%founds[0].getObject().getId())	#logging.info("unlock: %s"%founds[0].getObject().getId())
SESSION['author']=str(username)	SESSION['author']=str(username)

founds[0].getObject().lockedBy=""	founds[0].getObject().lockedBy=""
logging.info("unlocking done")
	logging.debug("uploadatffinallythread unlocking done")

#if a basketname is given, add files to the basket	#if a basketname is given, add files to the basket
if not (basketname ==''):	if not (basketname ==''):
logging.info("add to basket %s"%basketname)	logging.debug("uploadatffinallythread add to basket %s"%basketname)
self.result="<p>Add to basket</p>"+self.result	self.result="<p>Add to basket</p>"+self.result
basketId=ctx2.basketContainer.getBasketIdfromName(basketname)	basketId=ctx2.basketContainer.getBasketIdfromName(basketname)

if not basketId: # create new basket	if not basketId: # create new basket
logging.info("create basket %s"%basketname)	logging.debug("uploadatffinallythread create basket %s"%basketname)
self.result="<p>Create a new basket</p>"+self.result	self.result="<p>Create a new basket</p>"+self.result
ob=ctx2.basketContainer.addBasket(basketname)	ob=ctx2.basketContainer.addBasket(basketname)
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")

if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect(self.aq_parent.absolute_url())	RESPONSE.redirect(self.aq_parent.absolute_url())


logging.info("uploadfinally done")
return True	return True

class tmpStore(SimpleItem):	class tmpStore(SimpleItem):
Line 640 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.info("crrent: %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 933 class CDLIBasketContainer(OrderedFolder)	Line 933 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 949 class CDLIBasketContainer(OrderedFolder)	Line 952 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 1028 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:
	return False, -1

def history(self):	def history(self):
"""history"""	"""history"""
Line 1185 class CDLIBasket(Folder,CatalogAware):	Line 1191 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 1196 class CDLIBasket(Folder,CatalogAware):	Line 1206 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)))
	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]))

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 1337 class CDLIBasketVersion(Implicit,Persist	Line 1362 class CDLIBasketVersion(Implicit,Persist
security.declareProtected('manage','downloadObjectsAsOneFile')	security.declareProtected('manage','downloadObjectsAsOneFile')
def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):	def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):
"""download all selected files in one file"""	"""download all selected files in one file"""
	logging.debug("doasof")
if self.temp_folder.downloadCounterBaskets > 10000:	if self.temp_folder.downloadCounterBaskets > 10000:
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!"""

Line 1351 class CDLIBasketVersion(Implicit,Persist	Line 1376 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"""

	logging.debug("HIHHHH")
ret=""	ret=""
lockedObjects={}	lockedObjects={}

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

	logging.debug("lock:"+repr(lock))
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 1387 class CDLIBasketVersion(Implicit,Persist	Line 1406 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 1399 class CDLIBasketVersion(Implicit,Persist	Line 1415 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
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]
	logging.error(files)
	# 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\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 1520 class CDLIFileObject(CatalogAware,extVer	Line 1615 class CDLIFileObject(CatalogAware,extVer

security.declareProtected('manage','index_html')	security.declareProtected('manage','index_html')

	security.declarePublic('view')
	view = PageTemplateFile('zpt/viewCDLIFile.zpt', globals())

	security.declarePublic('editATF')
	editATF = PageTemplateFile('zpt/editATFFile.zpt', globals())

def PrincipiaSearchSource(self):	def PrincipiaSearchSource(self):
"""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 1534 class CDLIFileObject(CatalogAware,extVer	Line 1639 class CDLIFileObject(CatalogAware,extVer
def makeThisVersionCurrent(self,comment,author,RESPONSE=None):	def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
"""copy this version to current"""	"""copy this version to current"""
parent=self.aq_parent	parent=self.aq_parent
newversion=parent.manage_addCDLIFileObject('',comment,author)	parent.manage_addVersionedFileObject(id=None,vC=comment,author=author,file=self.getData(),RESPONSE=RESPONSE)
newversion.manage_upload(self.getData())	#newversion=parent.manage_addCDLIFileObject('',comment,author)
	#newversion.manage_upload(self.getData())

if RESPONSE is not None:	#if RESPONSE is not None:
RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')	# RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')

return True	return True

Line 1548 class CDLIFileObject(CatalogAware,extVer	Line 1654 class CDLIFileObject(CatalogAware,extVer
# return re.sub("\s\#lem"," #lem",data) #remove return vor #lem	# return re.sub("\s\#lem"," #lem",data) #remove return vor #lem
return re.sub("#lem"," #lem",data) #remove return vor #lem	return re.sub("#lem"," #lem",data) #remove return vor #lem

security.declarePublic('view')
def view(self):
"""view file"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','viewCDLIFile.zpt')).__of__(self)
return pt()

security.declarePublic('getPNumber')	security.declarePublic('getPNumber')
def getPNumber(self):	def getPNumber(self):
Line 1582 class CDLIFileObject(CatalogAware,extVer	Line 1683 class CDLIFileObject(CatalogAware,extVer
except:	except:
return "ERROR"	return "ERROR"


manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')	manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')

def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',versionNumber=0,	def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',versionNumber=0,
Line 1614 def manage_addCDLIFileObject(self,id,vC=	Line 1716 def manage_addCDLIFileObject(self,id,vC=
if content_type:	if content_type:
fob.content_type=content_type	fob.content_type=content_type

logging.debug("manage_add: lastversion=%s"%self.getData())	#logging.debug("manage_add: lastversion=%s"%self.getData())
logging.debug("reindex1: %s in %s"%(repr(self),repr(self.default_catalog)))	logging.debug("reindex1: %s in %s"%(repr(self),repr(self.default_catalog)))
self.reindex_object()	self.reindex_object()
logging.debug("manage_add: fob_data=%s"%fob.getData())	#logging.debug("manage_add: fob_data=%s"%fob.getData())
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 1696 class CDLIFile(extVersionedFile,CatalogA	Line 1799 class CDLIFile(extVersionedFile,CatalogA

def _newContentObject(self, id, title='', versionNumber=0, versionComment=None, time=None, author=None):	def _newContentObject(self, id, title='', versionNumber=0, versionComment=None, time=None, author=None):
"""factory for content objects. to be overridden in derived classes."""	"""factory for content objects. to be overridden in derived classes."""
	logging.debug("_newContentObject(CDLI)")
return CDLIFileObject(id,title,versionNumber=versionNumber,versionComment=versionComment,time=time,author=author)	return CDLIFileObject(id,title,versionNumber=versionNumber,versionComment=versionComment,time=time,author=author)


Line 1733 class CDLIFile(extVersionedFile,CatalogA	Line 1837 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 1765 def manage_addCDLIFile(self,id,title,loc	Line 1872 def manage_addCDLIFile(self,id,title,loc
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')


def checkUTF8(data):	def checkUTF8(data):
"""check utf 8"""	"""check utf 8"""
try:	try:
Line 1795 def splitatf(fh,dir=None,ext=None):	Line 1903 def splitatf(fh,dir=None,ext=None):
nf=None	nf=None
i=0	i=0

	#ROC: why split \n first and then \r???
if (type(fh) is StringType) or (type(fh) is UnicodeType):	if (type(fh) is StringType) or (type(fh) is UnicodeType):
iter=fh.split("\n")	iter=fh.split("\n")
else:	else:
Line 1856 class CDLIFileFolder(extVersionedFileFol	Line 1965 class CDLIFileFolder(extVersionedFileFol
#downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.	#downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
tmpStore2={}	tmpStore2={}

	def _newVersionedFile(self, id, title='', lockedBy=None, author=None):
	"""factory for versioned files. to be overridden in derived classes."""
	logging.debug("_newVersionedFile(CDLI)")
	return CDLIFile(id, title, lockedBy=lockedBy, author=author)

def setTemp(self,name,value):	def setTemp(self,name,value):
"""set tmp"""	"""set tmp"""

setattr(self,name,value)	setattr(self,name,value)

	deleteFileForm = PageTemplateFile("zpt/doDeleteFile", globals())

def delete(self,ids):	def delete(self,ids,REQUEST=None):
"""delete these files"""	"""delete these files"""
if type(ids) is not ListType:	if type(ids) is not ListType:
ids=[ids]	ids=[ids]

self.manage_delObjects(ids)	self.manage_delObjects(ids)

	if REQUEST is not None:
	return self.index_html()


def getVersionNumbersFromIds(self,ids):	def getVersionNumbersFromIds(self,ids):
"""get the numbers of the current versions of documents described by their ids"""	"""get the numbers of the current versions of documents described by their ids"""
Line 1924 class CDLIFileFolder(extVersionedFileFol	Line 2042 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 1958 class CDLIFileFolder(extVersionedFileFol	Line 2086 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 1984 class CDLIFileFolder(extVersionedFileFol	Line 2166 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 2112 class CDLIRoot(Folder):	Line 2293 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(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 2137 class CDLIRoot(Folder):	Line 2416 class CDLIRoot(Folder):
resultset = idx.search(query_request=idxQuery,sort_index='textid')	resultset = idx.search(query_request=idxQuery,sort_index='textid')
# put only the P-Number in the result	# put only the P-Number in the result
results = [res.getId[:7] for res in resultset]	results = [res.getId[:7] for res in resultset]
	logging.debug("searchtext: found %d texts"%len(results))
return results	return results


Line 2149 class CDLIRoot(Folder):	Line 2429 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 2175 class CDLIRoot(Folder):	Line 2454 class CDLIRoot(Folder):
# add whitespace before and whitespace and line-end to splitter bounds expressions	# add whitespace before and whitespace and line-end to splitter bounds expressions
bounds = self.splitter[indexName].bounds	bounds = self.splitter[indexName].bounds
splitexp = "(%s\|\s)(%%s)(%s\|\s\|\Z)"%(bounds,bounds)	splitexp = "(%s\|\s)(%%s)(%s\|\s\|\Z)"%(bounds,bounds)
# compile into regexp objects	# clean word expression
wordlist = [re.compile(splitexp%w) for w in word.split(' ')]	# TODO: this should use QueryParser itself
	# take out double quotes
	word = word.replace('"','')
	# take out ignorable signs
	ignorable = self.splitter[indexName].ignorex
	word = ignorable.sub('', word)
	# compile into regexp objects and escape parens
	wordlist = [re.compile(splitexp%re.escape(w)) for w in word.split(' ')]

for line in file.split("\n"):	for line in file.splitlines():
for word in wordlist:	for word in wordlist:
#logging.debug("showwordinfile: searching for %s in %s"%(word.pattern,line))	#logging.debug("showwordinfile: searching for %s in %s"%(word.pattern,ignoreable.sub('',line)))
if word.search(line):	if word.search(ignorable.sub('',line)):
line = formatAtfLineHtml(line)	line = formatAtfLineHtml(line)
ret.append(line)	ret.append(line)
break	break
Line 2190 class CDLIRoot(Folder):	Line 2476 class CDLIRoot(Folder):


def showWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):	def showWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
"""get lines with word from all ids in list FileIds"""	"""
	get lines with word from all ids in list FileIds.
	returns dict with id:lines pairs.
	"""
logging.debug("showwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds))	logging.debug("showwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds))
return [self.showWordInFile(id, word, indexName, regExp) for id in fileIds]
	return dict([(id,self.showWordInFile(id, word, indexName, regExp)) for id in fileIds])


def tagWordInFile(self,fileId,word,indexName='graphemes',regExp=False):	def tagWordInFile(self,fileId,word,indexName='graphemes',regExp=False):
Line 2208 class CDLIRoot(Folder):	Line 2498 class CDLIRoot(Folder):
# add whitespace to splitter bounds expressions and compile into regexp object	# add whitespace to splitter bounds expressions and compile into regexp object
bounds = self.splitter[indexName].bounds	bounds = self.splitter[indexName].bounds
wordsplit = re.compile("(%s\|\s)"%bounds)	wordsplit = re.compile("(%s\|\s)"%bounds)
	# clean word expression
	# TODO: this should use QueryParser itself
	word = word.replace('"','') # take out double quotes
	# take out ignoreable signs
	ignorable = self.splitter[indexName].ignorex
	word = ignorable.sub('', word)
# split search terms by blanks	# split search terms by blanks
words = word.split(' ')	words = word.split(' ')
	# split search terms again (for grapheme search with words)
	splitwords = dict(((w,self.splitter[indexName].process([w])) for w in words))

for line in file.split("\n"):	for line in file.splitlines():
line = unicodify(line)	line = unicodify(line)
# ignore lemma lines	# ignore lemma and other lines
if line.lstrip().startswith('#lem:'):	if line.lstrip().startswith('#lem:'):
continue	continue
	# ignore p-num line
	if line.startswith('&P'):
	continue
	# ignore version lines
	if line.startswith('#version'):
	continue
	# ignore atf type lines
	if line.startswith('#atf:'):
	continue

# first scan	# first scan
hitwords = []	hitwords = []
for w in words:	for w in words:
if line.find(w) > -1:	if ignorable.sub('',line).find(w) > -1:
# word is in line	# word is in line
hitwords.append(w)	# append split word for grapheme search with words
	hitwords.extend(splitwords[w])
	#hitwords.extend(wordsplit.split(w))

# examine hits closer	# examine hits closer
if hitwords:	if hitwords:
Line 2230 class CDLIRoot(Folder):	Line 2539 class CDLIRoot(Folder):
parts = wordsplit.split(line)	parts = wordsplit.split(line)
line = ""	line = ""
for p in parts:	for p in parts:
	#logging.debug("tagwordinfile: searching for %s in %s"%(p,hitwords))
# reassemble line	# reassemble line
if p in hitwords:	if ignorable.sub('', p) in hitwords:
	#logging.debug("tagwordinfile: found %s in %s"%(p,hitwords))
# this part was found	# this part was found
line += tagStart + formatAtfHtml(p) + tagEnd	line += tagStart + formatAtfHtml(p) + tagEnd
else:	else:
Line 2248 class CDLIRoot(Folder):	Line 2559 class CDLIRoot(Folder):


def tagWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):	def tagWordInFiles(self,fileIds,word,indexName='graphemes',regExp=False):
"""get texts with word from all ids in list FileIds"""	"""
	get texts with highlighted word from all ids in list FileIds.
	returns dict with id:text pairs.
	"""
logging.debug("tagwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds))	logging.debug("tagwordinfiles word='%s' index=%s file=%s"%(word,indexName,fileIds))
return [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):
Line 2325 class CDLIRoot(Folder):	Line 2648 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 2501 class CDLIRoot(Folder):	Line 2829 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())

def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):	def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/atf", files=None,ext=None):
"""import files"""	"""import files"""
	logging.debug("importFiles folderName=%s files=%s ext=%s"%(folderName,files,ext))
root=self.cdli_main	root=self.cdli_main
count=0	count=0
if not files:	if not files:
Line 2515 class CDLIRoot(Folder):	Line 2855 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))
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()

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))

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
manage_addCDLIFile(fobj2,f,'','')	logging.debug("importFiles: addCDLIFile fobj2=%s, f=%s file2=%s"%(fobj2,repr(f),repr(file2)))
id=f	fobj2.addFile(vC='',file=file(file2),author=author,newName=f)
ob=fobj2._getOb(f)
ob.title=id

manage_addCDLIFileObject(ob,id,comment,author,file2,content_type='',from_tmp=True)
self.CDLICatalog.catalog_object(ob)
#self.CDLICatalog.manage_catalogFoundItems(obj_ids=[id],search_sub=1)
#self.CDLICatalog.manage_catalogObject(self.REQUEST, self.REQUEST.RESPONSE, 'CDLICatalog', urlparse.urlparse(ob.absolute_url())[1])
count+=1	count+=1

if count > 1000:	#now add the file to the storage
print "committing"	ob = getattr(fobj2,f)
	self.cdliRoot.updateOrAddToFileBTree(ob)

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

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

Removed from v.1.80.2.8
changed lines
	Added in v.1.91