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.55 and 1.67

version 1.55, 2006/12/22 20:35:33	version 1.67, 2007/03/19 18:34:01
Line 22 from ZPublisher.HTTPResponse import HTTP	Line 22 from ZPublisher.HTTPResponse import HTTP
from ZPublisher.BaseRequest import RequestContainer	from ZPublisher.BaseRequest import RequestContainer
import threading	import threading
from BTrees.OOBTree import OOBTree	from BTrees.OOBTree import OOBTree
	import logging
	import transaction
	import copy
	import codecs

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 134 class uploadATFfinallyThread(Thread):	Line 138 class uploadATFfinallyThread(Thread):
self.username=username	self.username=username
self.serverport=serverport	self.serverport=serverport


def __call__(self):	def __call__(self):
"""call of the thread (equals run)"""	"""call of the thread (equals run)"""
self.run()	self.run()
Line 166 class uploadATFfinallyThread(Thread):	Line 171 class uploadATFfinallyThread(Thread):
#add the files	#add the files
self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)	self.uploadATFfinallyThread(ctx,self.procedure,comment=self.comment,basketname=self.basketname,unlock=self.unlock,SESSION=self.SESSION,username=self.username)
#commit the transactions	#commit the transactions
get_transaction().commit()	transaction.get().commit()
conn.close()	conn.close()
#set flag for end of this method	#set flag for end of this method
self.end=True	self.end=True
print "ended"	logging.info("ended")
return True	return True

def __del__(self):	def __del__(self):
Line 192 class uploadATFfinallyThread(Thread):	Line 197 class uploadATFfinallyThread(Thread):

#shall I only upload the changed files?	#shall I only upload the changed files?
if procedure=="uploadchanged":	if procedure=="uploadchanged":
	changed=[x[0] for x in SESSION.get('changed',[])]
uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])	uploadFns=changed+SESSION.get('newPs',[])

#or all	#or all
elif procedure=="uploadAll":	elif procedure=="uploadAll":
Line 209 class uploadATFfinallyThread(Thread):	Line 214 class uploadATFfinallyThread(Thread):
uploadFns=[]	uploadFns=[]

#do first the changed files	#do first the changed files
	i=0
for fn in uploadFns:	for fn in uploadFns:
	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="<p>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:
	i=0
	transaction.get().commit()
	logging.info("changing: do commit")

	transaction.get().commit()
	logging.info("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']
self.result+="<p>Adding files</p>"	logging.info("adding start")
	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")


#unlock locked files?	#unlock locked files?
if unlock:	if unlock:
self.result+="<p>Unlock files</p>"	logging.info("unlocking start")
	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")

for fn in unlockFns:	for fn in unlockFns:
	#logging.info("will unlock: %s"%fn)
founds=ctx2.CDLICatalog.search({'title':fn})	founds=ctx2.CDLICatalog.search({'title':fn})
	#logging.info("found it: %s"%repr(founds))
if len(founds)>0:	if len(founds)>0:
	#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")

#if a basketname is give, add files to the basket	#if a basketname is given, add files to the basket
if not (basketname ==''):	if not (basketname ==''):
self.result+="<p>Add basket</p>"	logging.info("add to basket %s"%basketname)
	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)
	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))
Line 259 class uploadATFfinallyThread(Thread):	Line 282 class uploadATFfinallyThread(Thread):
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):
	"""simple item"""
	meta_type="cdli_upload"

	def __init__(self,id):
	"""init tmp"""
	self.id=id

class uploadATFThread(Thread):	class uploadATFThread(Thread):
"""class for checking the files befor uploading"""	"""class for checking the files befor uploading"""

Line 274 class uploadATFThread(Thread):	Line 305 class uploadATFThread(Thread):
Thread.__init__(self)	Thread.__init__(self)


def set(self,upload,basketId,username,serverport="8080"):	def set(self,upload,basketId,username,idTmp,serverport="8080"):
"""set start values for the thread"""	"""set start values for the thread"""
self.result=""	self.result=""
self.upload=upload	self.upload=upload
self.basketId=basketId	self.basketId=basketId
self.username=username	self.username=username
self.serverport=serverport	self.serverport=serverport
	self.idTmp=idTmp

def __call__(self):	def __call__(self):
"""call method """	"""call method """
Line 299 class uploadATFThread(Thread):	Line 331 class uploadATFThread(Thread):
return app.__of__(RequestContainer(REQUEST = req))	return app.__of__(RequestContainer(REQUEST = req))

def run(self):	def run(self):
	idTmp=self.idTmp
self.result=""	self.result=""
#find context within ZODB	#find context within ZODB
from Zope import DB	from Zope import DB
Line 307 class uploadATFThread(Thread):	Line 339 class uploadATFThread(Thread):
root = conn.root()	root = conn.root()
app = root['Application']	app = root['Application']
ctx = self.getContext(app,serverport=self.serverport)	ctx = self.getContext(app,serverport=self.serverport)
self.uploadATFThread(ctx,self.upload,self.basketId)	logging.info("run intern")
	try:
	ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
	except:
	logging.error("thread upload: %s %s"%sys.exc_info()[0:2])

	logging.info("call thread intern")
	self.uploadATFThread(ctx,self.upload,idTmp,self.basketId)

#ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue	#ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue

get_transaction().commit()

while self.continueVar:	transaction.get().commit()
pass

conn.close()	conn.close()

Line 323 class uploadATFThread(Thread):	Line 360 class uploadATFThread(Thread):
"""method for accessing result"""	"""method for accessing result"""
return self.result	return self.result

def uploadATFThread(self,ctx,upload,basketId=0):	def uploadATFThread(self,ctx,upload,idTmp,basketId=0):
"""upload an atf file"""	"""upload an atf file"""
#TODO: add comments	#TODO: add comments
#TODO: finish uploadATF	#TODO: finish uploadATF

	stObj=getattr(ctx.temp_folder,idTmp)
	logging.info("start, upload thread")
self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"	self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"

#make sure that id is a string and not an integer	#make sure that id is a string and not an integer
Line 365 class uploadATFThread(Thread):	Line 405 class uploadATFThread(Thread):
basketNameFromId=getattr(ctx2.basketContainer,basketId).title	basketNameFromId=getattr(ctx2.basketContainer,basketId).title
basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()	basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()

	logging.info("got the file, upload thread")
self.result+="""<html><body><h2>I got the files</h2><	self.result+="""<html><body><h2>I got the files</h2><
p>I am computing the differences to the exisiting files</p>"""	p>I am computing the differences to the exisiting files</p>"""

#start to check the files	#start to check the files
for fn in os.listdir(dir):	for fn in os.listdir(dir):

self.result+="<p>process:%s</p>"%fn	self.result="<p>process:%s</p>"%fn+self.result

# check if file is in the catalog	# check if file is in the catalog
#TODO: checkCatalog is not implemented yet	#TODO: checkCatalog is not implemented yet
Line 400 class uploadATFThread(Thread):	Line 440 class uploadATFThread(Thread):
obj=found.getObject()	obj=found.getObject()

if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):	if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
lockerrors.append(fn)	lockerrors.append((fn,str(obj.lockedBy)))
else:	else:

diffs=obj.diff(data)	diffs=obj.diff(data)
Line 410 class uploadATFThread(Thread):	Line 450 class uploadATFThread(Thread):
#ready, set the returnValues	#ready, set the returnValues
self.result+="<h3>Done</h3></body></html>"	self.result+="<h3>Done</h3></body></html>"

self.returnValue={}	stObj.returnValue={}
self.returnValue['changed']=changed
self.returnValue['errors']=errors
self.returnValue['lockerrors']=lockerrors
self.returnValue['newPs']=newPs
self.returnValue['tmpdir']=dir
self.returnValue['basketLen']=basketLen
self.returnValue['numberOfFiles']=numberOfFiles
self.returnValue['basketNameFromId']=basketNameFromId
self.returnValue['basketNameFromFile']=basketNameFromFile
self.returnValue['basketId']=basketId
self.returnValue['dir']=dir

#ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)


class Basket_old(Folder):
"""shopping basket - alte fassung """

meta_type="Basket"
_v_stack={}

def getObjUrl(self,objId):
"""getUrl"""
founds=self.CDLICatalog.search({'title':objId})
if len(founds)>0:
return founds[0].getObject().absolute_url()

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

def storeAllLink(self,results):
"""erzeuge link zum speicher aller results"""
nr=self.REQUEST['_ZopeId']

if results:
self._v_stack[nr]=[x.getObject().getId() for x in results]

return self.absolute_url()+"/storeAll?id="+nr

def storeAll(self,id):
"""store all"""
try:
results=self._v_stack[id]
except:
#TODO: write expired page
return "expired"

return self.storeInBasketForm(results)

def storeInBasketForm(self,ids):
""" store an object form"""

if type(ids) is not ListType:
ids=[ids]
self.REQUEST.SESSION['ids']=ids[0:]

self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']

pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','storeBasketObject.zpt')).__of__(self)
return pt()

def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):
"""store it"""

if not ids:
ids=REQUEST.SESSION['ids']

self.REQUEST.SESSION['basketUser']=username

baskets=self.ZopeFind(self,obj_ids=[username])
if len(baskets)>0:
basket=baskets[0][1]
else:
manage_addBasketObject(self,username)
basket=self._getOb(username)


basket.addObjects(ids)
back=self.REQUEST.SESSION.get('BACKLINK', None)

if RESPONSE:
RESPONSE.redirect(back)



def showBasket(self,user=None,set=None,RESPONSE=None):
"""show the basket"""

if user:	stObj.returnValue['errors']=errors
self.REQUEST.SESSION['basketUser']=user

if not user and not set:	stObj.returnValue['newPs']=newPs
user=self.REQUEST.SESSION.get('basketUser',None)	stObj.returnValue['tmpdir']=dir
	stObj.returnValue['basketLen']=basketLen
if not user:	stObj.returnValue['numberOfFiles']=numberOfFiles
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)	stObj.returnValue['basketNameFromId']=basketNameFromId
return pt()	stObj.returnValue['basketNameFromFile']=basketNameFromFile
else:	stObj.returnValue['basketId']=basketId
baskets=self.ZopeFind(self,obj_ids=[user])	stObj.returnValue['dir']=dir
	#stObj.returnValue['changed']=copy.copy(changed)
	stObj.returnValue['changed']=[(x[0].getId(),x[1][0]) for x in changed]
if len(baskets)>0:	#stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors]
RESPONSE.redirect(baskets[0][1].absolute_url())	stObj.returnValue['lockerrors']=[x for x in lockerrors]
return True	self.returnValue=True
else:	#ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)
return pt()


def manage_addBasket_oldForm(self):
"""add the basket form"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)
return pt()

def manage_addBasket_old(self,id,title,RESPONSE=None):
"""add the basket"""
ob=Basket()

ob.id=str(id)
ob.title=title
self._setObject(id, ob)
ob=self._getOb(id)

if RESPONSE is not None:
RESPONSE.redirect('manage_main')


class BasketObject_old(Folder):
"""Basket Object - alte fassung"""

meta_type="basketObject"
def __init__(self):
"""init basket object"""
self.contents=[]

def numberOfItems(self):
"""return anzahl der elemente im basket"""
num=len(self.contents)

return num

def addObjects(self,ids):
"""addObjects"""

for id in ids:
founds=self.CDLICatalog.search({'title':id})
for found in founds:
if found.getObject() not in self.contents:
tm=self.contents[0:]
tm.append(found.getObject())
self.contents=tm[0:]

return True

def index_html(self):
"""view the basket"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
return pt()

def deleteObjects(self,ids,RESPONSE=None):
"""delete objects"""
list = self.contents[0:]
for content in list:

if content.getId() in ids:
self.contents.remove(content)


if RESPONSE:
RESPONSE.redirect(self.absolute_url())


def unlockTest(self):
"""unlock all files of the testuser for debuggin"""
for object in self.contents:

if str(object.lockedBy)=="test":
object.lockedBy=""

def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
"""download all selected files in one file"""

ret=""
lockedObjects={}

if self.temp_folder.downloadCounter > 10:
return """I am sorry, currently the server has to many requests for downloads, please come back later!"""


if lock:

if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':

return "please login first"

#check if a locked object exist in the basket.
lockedObjects={}
for object in self.contents:

if not object.lockedBy=="":
lockedObjects[object.title]=repr(object.lockedBy)


keys=lockedObjects.keys()


if len(keys)>0 and (not procedure):
self.REQUEST.SESSION['lockedObjects']=lockedObjects
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
return pt()

elif not procedure: #keine fails gesperrt dann alle donwloaden
procedure="downloadAll"

self.temp_folder.downloadCounter+=1
self._p_changed=1
get_transaction().commit()


for object in self.contents:

if (procedure=="downloadAll") or (object.lockedBy=='') or (object.lockedBy==self.REQUEST['AUTHENTICATED_USER']):
ret+=object.getLastVersion().getData()

if lock and object.lockedBy=='':
object.lockedBy=self.REQUEST['AUTHENTICATED_USER']


self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="basket_%s.atf" """%self.getId())
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
length=len(ret)
self.REQUEST.RESPONSE.setHeader("Content-Length",length)
self.REQUEST.RESPONSE.write(ret)
self.temp_folder.downloadCounter-=1
self._p_changed=1
get_transaction().commit()


def manage_addBasket_oldObjectForm(self):
"""add form"""
pass

def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):
"""add"""

ob=BasketObject()

ob.id=str(id)
ob.title=title
self._setObject(id, ob)
ob=self._getOb(id)

if RESPONSE is not None:
RESPONSE.redirect('manage_main')


class CDLIBasketContainer(OrderedFolder):	class CDLIBasketContainer(OrderedFolder):
Line 1043 class CDLIBasket(Folder,CatalogAware):	Line 844 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"""
	logging.info("add to basket (%s)"%(self.getId()))
lastVersion=self.getLastVersion()	lastVersion=self.getLastVersion()

if lastVersion is None:	if lastVersion is None:
Line 1061 class CDLIBasket(Folder,CatalogAware):	Line 862 class CDLIBasket(Folder,CatalogAware):
founds=self.CDLICatalog.search({'title':id})	founds=self.CDLICatalog.search({'title':id})
except:	except:
founds=[]	founds=[]

for found in founds:	for found in founds:
if found.getObject() not in oldContent:	if found.getObject() not in oldContent:
#TODO: was passiert wenn, man eine Object dazuf�gt, das schon da ist aber eine neuere version	#TODO: was passiert wenn, man eine Object dazuf�gt, das schon da ist aber eine neuere version
Line 1074 class CDLIBasket(Folder,CatalogAware):	Line 876 class CDLIBasket(Folder,CatalogAware):
user = username	user = username

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


Line 1191 class CDLIBasketVersion(Implicit,Persist	Line 993 class CDLIBasketVersion(Implicit,Persist

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

if lock:	if lock:

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

#check if a locked object exist in the basket.	#check if a locked object exist in the basket.
lockedObjects={}	lockedObjects={}
for object in self.content.getContent():	for object in self.content.getContent():

if not object[1].lockedBy=="":	if (not str(object[1].lockedBy)=="") and (not (str(object[1].lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):
lockedObjects[object[1].title]=repr(object[1].lockedBy)	lockedObjects[object[1].title]=repr(object[1].lockedBy)


Line 1221 class CDLIBasketVersion(Implicit,Persist	Line 1023 class CDLIBasketVersion(Implicit,Persist

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

return pt()	return pt()

Line 1251 class CDLIBasketVersion(Implicit,Persist	Line 1053 class CDLIBasketVersion(Implicit,Persist

self.temp_folder.downloadCounterBaskets-=1	self.temp_folder.downloadCounterBaskets-=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	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")
Line 1368 class CDLIFileObject(CatalogAware,extVer	Line 1170 class CDLIFileObject(CatalogAware,extVer


newversion=parent.manage_addCDLIFileObject('',comment,author)	newversion=parent.manage_addCDLIFileObject('',comment,author)
newversion.data=self.data[0:]	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')
Line 1648 def splitatf(fh,dir=None,ext=None):	Line 1450 def splitatf(fh,dir=None,ext=None):
i=0	i=0

for lineTmp in fh.readlines():	for lineTmp in fh.readlines():
	lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..
for line in lineTmp.split("\r"):	for line in lineTmp.split("\r"):
	#logging.log("Deal with: %s"%line)
if ext:	if ext:
i+=1	i+=1
if (i%100)==0:	if (i%100)==0:
Line 1674 def splitatf(fh,dir=None,ext=None):	Line 1478 def splitatf(fh,dir=None,ext=None):
if dir:	if dir:
filename=os.path.join(dir,filename)	filename=os.path.join(dir,filename)
nf=file(filename,"w")	nf=file(filename,"w")
	logging.info("open %s"%filename)
if nf:	if nf:
nf.write(line.replace("\n","")+"\n")	nf.write(line.replace("\n","")+"\n")

	try:
nf.close()	nf.close()
	except:
	pass
fh.close()	fh.close()
return ret,len(os.listdir(dir))	return ret,len(os.listdir(dir))

Line 1729 class CDLIFileFolder(extVersionedFileFol	Line 1537 class CDLIFileFolder(extVersionedFileFol

return ret	return ret

	def getFile(self,fn):
	"""get the content of the file fn"""
	founds=self.CDLICatalog.search({'title':fn})
	if not founds:
	return []
	else:
	obj=founds[0].getObject().getLastVersion()
	logging.error(obj.getData())
	return obj.getData()[0:]

def checkCatalog(self,fn):	def checkCatalog(self,fn):
"""check if fn is in the catalog"""	"""check if fn is in the catalog"""
#TODO add checkCatalog	#TODO add checkCatalog
Line 1751 class CDLIFileFolder(extVersionedFileFol	Line 1569 class CDLIFileFolder(extVersionedFileFol
return pt(search=list,author=author)	return pt(search=list,author=author)


	def getAllPNumbers(self):
	"""get a list of all files (resp their p-numbers) stored"""

	ret=[x.getId for x in self.CDLICatalog()]

	return ret

def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):	def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
"""findObjectsFromList (, TAB oder LINE separated)"""	"""findObjectsFromList (, TAB oder LINE separated)"""
Line 1830 class CDLIFileFolder(extVersionedFileFol	Line 1654 class CDLIFileFolder(extVersionedFileFol

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

list=[(x.getId,x) for x in catalog()]	list=[(x.getId,x) for x in catalog()]
list.sort(sortF)	list.sort(sortF)
Line 1850 class CDLIFileFolder(extVersionedFileFol	Line 1674 class CDLIFileFolder(extVersionedFileFol
RESPONSE.write(obj.getLastVersion().getData()[0:])	RESPONSE.write(obj.getLastVersion().getData()[0:])
self.temp_folder.downloadCounter-=1	self.temp_folder.downloadCounter-=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()
#os.close(tf)	#os.close(tf)
#RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)	#RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
return True	return True
Line 1932 class CDLIRoot(Folder):	Line 1756 class CDLIRoot(Folder):
meta_type="CDLIRoot"	meta_type="CDLIRoot"
downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible	downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible

	def findWordRegExp(self,searchTerm):
	"""find all words in index which match regexp in SearchTerm"""
	ret=[]
	for x in self.lineIndex.iterkeys():
	if re.match(searchTerm,x):
	ret.append(x)
	return ret

	def searchRegExpInLineIndexDocs(self,searchTerm):
	"""search in inLineIndex with regexp"""
	if not searchTerm:
	return []
	ret=[]
	words=self.findWordRegExp(searchTerm) # suche nach allen Treffern
	logging.info("wd:%s"%words)
	for word in words:
	ret+=self.searchInLineIndexDocs(word)

	return unique(ret)

def showInLineIndex(self):	def showInLineIndex(self):
"""get the index for debug purposes"""	"""get the index for debug purposes"""
print "show"	print "show"
for x in self.lineIndex.iterkeys():	for x in self.lineIndex.iterkeys():
print "word:",x	logging.info("word:%s"%repr(x))
for y in self.lineIndex[x].iterkeys():	#for y in self.lineIndex[x].iterkeys():
print "doc",y,self.lineIndex[x][y]	# print "doc",repr(y),repr(self.lineIndex[x][y])

return self.lineIndex	return self.lineIndex

def searchInLineIndexDocs(self,word,uniq=True):	def searchInLineIndexDocs(self,word,uniq=True,regExp=False):
"""search occurences"""	"""search occurences"""

	if regExp:
	return self.searchRegExpInLineIndexDocs(word)

lst=list(self.lineIndex.get(word.upper()).keys())	try:
	lst=list(self.lineIndex.get(word).keys())
	except:
	lst=[]
if uniq:	if uniq:
return unique(lst)	return unique(lst)
else:	else:
return lst	return lst

def getLinesFromIndex(self,word,doc):	def getLinesFromIndex(self,word,doc,regExp=False):
"""get lines"""	"""get lines"""
return self.lineIndex[word][doc]	if not regExp:
	return self.lineIndex.get(word)[doc]
	else: # wenn regexp, suche welches word
	for w in self.findWordRegExp(word):
	if self.lineIndex.get(w): # ein word in im dex gefunden
	try:
	dc=self.lineIndex.get(word)[doc]
	return dc # und ein document dann gib es zurueck
	except:
	pass #andernfalls weiter

def cleanInLineIndex(self):	def cleanInLineIndex(self):
"""delete InlineIndex"""	"""delete InlineIndex"""
Line 1989 class CDLIRoot(Folder):	Line 1847 class CDLIRoot(Folder):

self.lineIndex=li	self.lineIndex=li

get_transaction().commit()	transaction.get().commit()


def showFile(self,fileId):	def showFile(self,fileId):
Line 2000 class CDLIRoot(Folder):	Line 1858 class CDLIRoot(Folder):

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

def showLineFromFile(self,fileId,lineNum):	def showLineFromFile(self,fileId,lineNum,word):
"""get line lineNum fromFileId"""	"""get line lineNum fromFileId"""

file=self.showFile(fileId)	file=self.showFile(fileId)
str="^%s\.(.*)"%lineNum	#str="^%s\.[^%s\.]%s[^\n]\n"%(lineNum,lineNum,word)
	#str="^%s\..?%s[^\n]\n"%(lineNum,word)

	#print str
	#m=re.search(str,file,flags=re.M\|re.DOTALL)
	#if m:
	# return m.group()
	#else:
	# return ""
	#ret=lineNum+"."
	#splitted=file.split(lineNum+".")
	#if len(splitted)>1:
	#for part in splitted[1:]:
	#if part.find(word)>-1:
	# for x in part.split("\n"):
	#ret+=x
	#if x.find(word)>-1:
	#break
	#break;
	#return ret

	def showWordInFile(self,fileId,word,lineList=None):
	"""get lines with word fromFileId"""

	file=self.showFile(fileId)

	ret=[]
	for line in file.split("\n"):
	if line.find(word)>-1:
	if lineList: #liste of moeglichen Zeilennummern
	num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile

	if num in lineList:

	ret.append(line)
	else: # nimm alles ohne line check
	ret.append(line)
	return ret

	def tagWordInFile(self,fileId,word,lineList=None):
	"""get lines with word fromFileId"""

m=re.search(str,file,flags=re.M)	file=self.showFile(fileId)
if m:	tagStr="""<span class="found">%s</span>"""
return m.group(1)	ret=[]
	for line in file.split("\n"):
	if line.find(word)>-1:
	if lineList: #liste of moeglichen Zeilennummern
	num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile

	if num in lineList:

	ret.append(line.replace(word,tagStr%word))
	else: # nimm alles ohne line check
	ret.append(line.replace(word,tagStr%word))
else:	else:
return ""	ret.append(line)
	return "<br>\n".join(ret)

def URLquote(self,str):	def URLquote(self,str):
"""quote url"""	"""quote url"""
Line 2020 class CDLIRoot(Folder):	Line 1929 class CDLIRoot(Folder):
"""unquote url"""	"""unquote url"""
return urllib.unquote(str)	return urllib.unquote(str)

	def URLquote_plus(self,str):
	"""quote url"""
	return urllib.quote_plus(str)

	def URLunquote_plus(self,str):
	"""unquote url"""
	return urllib.unquote_plus(str)


def forceunlock(self):	def forceunlock(self):
"break all locks"	"break all locks"
Line 2032 class CDLIRoot(Folder):	Line 1949 class CDLIRoot(Folder):

return ret	return ret

	def forceDahl(self):
	"break all locks"
	ret=[]
	for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
	if str(f[1].lockedBy)=="dahl":
	un=f[1].forceunlock()

	if un and un !="":
	ret.append((f[0],un))

	return ret

def getChangesByAuthor(self,author,n=100):	def getChangesByAuthor(self,author,n=100):
"""getChangesByAuthor"""	"""getChangesByAuthor"""
zcat=self.CDLIObjectsCatalog	zcat=self.CDLIObjectsCatalog
Line 2097 class CDLIRoot(Folder):	Line 2026 class CDLIRoot(Folder):
def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):	def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
"""standard ausgabe"""	"""standard ausgabe"""
#self._v_uploadATF.returnValue=None	#self._v_uploadATF.returnValue=None
	from random import randint
	if (not self.REQUEST.SESSION.get('idTmp',None)):

	idTmp=str(randint(0,1000000000))
	self.REQUEST.SESSION['idTmp']=idTmp
	else:
	idTmp=self.REQUEST.SESSION.get('idTmp',None)

threadName=repeat	threadName=repeat
if not threadName or threadName=="":	if not threadName or threadName=="":
Line 2110 class CDLIRoot(Folder):	Line 2046 class CDLIRoot(Folder):
self._v_uploadATF[threadName]=thread	self._v_uploadATF[threadName]=thread
#self._xmltrans.start()	#self._xmltrans.start()
#thread=Thread(target=self._v_uploadATF)	#thread=Thread(target=self._v_uploadATF)
	logging.info("set thread. extern")
self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])	self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],idTmp,serverport=self.REQUEST['SERVER_PORT'])
#thread.start()	#thread.start()
	logging.info("start thread. extern")
self._v_uploadATF[threadName].start()	self._v_uploadATF[threadName].start()


Line 2134 class CDLIRoot(Folder):	Line 2071 class CDLIRoot(Folder):
if threadName == thread.getName():	if threadName == thread.getName():
self._v_uploadATF[threadName]=thread	self._v_uploadATF[threadName]=thread

if not self._v_uploadATF[threadName].returnValue:	if self._v_uploadATF.get(threadName,None) and (not self._v_uploadATF[threadName].returnValue):


wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])	wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
Line 2157 class CDLIRoot(Folder):	Line 2094 class CDLIRoot(Folder):
#	#
# #	# #
#tmp=self.cdli_main.tmpStore2[threadName]	#tmp=self.cdli_main.tmpStore2[threadName]
tmp=self._v_uploadATF[threadName].returnValue

self._v_uploadATF[threadName].continueVar=False	tmp=getattr(self.temp_folder,idTmp).returnValue




self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]
self.REQUEST.SESSION['lockerrors']=[x[0].getId() for x in tmp['lockerrors']]
self.REQUEST.SESSION['errors']=tmp['errors']
self.REQUEST.SESSION['newPs']=tmp['newPs']
self.REQUEST.SESSION['tmpdir']=tmp['dir']
#del(self.cdli_main.tmpStore2[threadName])	#del(self.cdli_main.tmpStore2[threadName])


Line 2197 class CDLIRoot(Folder):	Line 2131 class CDLIRoot(Folder):

self._v_uploadATF[threadName]=thread	self._v_uploadATF[threadName]=thread

	idTmp=self.REQUEST.SESSION['idTmp']
self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])	stObj=getattr(self.temp_folder,idTmp)
	self._v_uploadATF[threadName].set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=stObj.returnValue,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])

self._v_uploadATF[threadName].start()	self._v_uploadATF[threadName].start()

Line 2231 class CDLIRoot(Folder):	Line 2166 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:
	self.REQUEST.SESSION['idTmp']=None
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect(self.absolute_url())	RESPONSE.redirect(self.absolute_url())

Line 2248 class CDLIRoot(Folder):	Line 2183 class CDLIRoot(Folder):
obj=self.ZopeFind(root,obj_ids=[folder])	obj=self.ZopeFind(root,obj_ids=[folder])
if ext:	if ext:

ext.result+="<p>adding: %s </p>"%f	ext.result="<p>adding: %s </p>"%f+ext.result
if not obj:	if not obj:
manage_addCDLIFileFolder(root,folder,folder)	manage_addCDLIFileFolder(root,folder,folder)
fobj=getattr(root,folder)	fobj=getattr(root,folder)
#get_transaction().commit()	#transaction.get().commit()
else:	else:
fobj=obj[0][1]	fobj=obj[0][1]

Line 2280 class CDLIRoot(Folder):	Line 2215 class CDLIRoot(Folder):

if count > 1000:	if count > 1000:
print "committing"	print "committing"
get_transaction().commit()	transaction.get().commit()
count=0	count=0
get_transaction().commit()	transaction.get().commit()
return "ok"	return "ok"


Line 2302 def manage_addCDLIRoot(self, id, title='	Line 2237 def manage_addCDLIRoot(self, id, title='
ob=CDLIRoot()	ob=CDLIRoot()
ob.id=str(id)	ob.id=str(id)
ob.title=title	ob.title=title
	try:
self._setObject(id, ob)	self._setObject(id, ob)
	except:
	pass
ob=self._getOb(id)	ob=self._getOb(id)

checkPermission=getSecurityManager().checkPermission	checkPermission=getSecurityManager().checkPermission

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

Removed from v.1.55
changed lines
	Added in v.1.67