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.19 and 1.44

version 1.19, 2006/06/13 18:34:10	version 1.44, 2006/08/24 09:28:29
Line 13 from OFS.Folder import manage_addFolder	Line 13 from OFS.Folder import manage_addFolder
import re	import re
from AccessControl import ClassSecurityInfo	from AccessControl import ClassSecurityInfo
from Acquisition import Implicit	from Acquisition import Implicit
	from Globals import Persistent
from threading import Thread	from threading import Thread
from ZPublisher.HTTPRequest import HTTPRequest	from ZPublisher.HTTPRequest import HTTPRequest
from ZPublisher.HTTPResponse import HTTPResponse	from ZPublisher.HTTPResponse import HTTPResponse
from ZPublisher.BaseRequest import RequestContainer	from ZPublisher.BaseRequest import RequestContainer
	import threading


	class BasketContent(SimpleItem):
	"""classe fuer den Inhalt eines Baskets"""

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

	def getContent(self):
	"""get content"""

	return self.contentList

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

	def numberOfItems(self):
	"""number"""

	return len(self.getContent())

global tmpVar

class uploadATFfinallyThread(Thread):	class uploadATFfinallyThread(Thread):
	"""class for adding uploaded filed (temporarily stored in the staging area at /tmp"""

def __init__(self):	def __init__(self):
	"""init for uploadATFfinallyThread"""
self.continueVar=True	self.continueVar=True
self.returnValue=None	self.returnValue=None
self.end=False	self.end=False
Thread.__init__(self)	Thread.__init__(self)

def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):	def set(self,procedure,comment="",basketname='',unlock=None,SESSION=None,username=None,serverport="8080"):
"""set values"""	"""set start values for the thread"""
self.procedure=procedure	self.procedure=procedure
self.comment=comment	self.comment=comment
self.basketname=basketname	self.basketname=basketname
Line 39 class uploadATFfinallyThread(Thread):	Line 63 class uploadATFfinallyThread(Thread):
self.serverport=serverport	self.serverport=serverport

def __call__(self):	def __call__(self):
"""wait"""	"""call of the thread (equals run)"""
self.run()	self.run()
return True	return True

def getContext(self, app,serverport="8080"):	def getContext(self, app,serverport="8080"):
	"""get the context within the ZODB"""

resp = HTTPResponse(stdout=None)	resp = HTTPResponse(stdout=None)
env = {	env = {
'SERVER_NAME':'localhost',	'SERVER_NAME':'localhost',
Line 55 class uploadATFfinallyThread(Thread):	Line 81 class uploadATFfinallyThread(Thread):


def run(self):	def run(self):
	"""run"""

self.result=""	self.result=""
	#find context within ZODB
from Zope import DB	from Zope import DB
conn = DB.open()	conn = DB.open()
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)

	#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
get_transaction().commit()	get_transaction().commit()
conn.close()	conn.close()
	#set flag for end of this method
self.end=True	self.end=True
return True	return True

	def __del__(self):
	"""delete"""



def getResult(self):	def getResult(self):
	"""method for accessing result"""

return self.result	return self.result

def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):	def uploadATFfinallyThread(self,ctx,procedure,comment="",basketname='',unlock=None,RESPONSE=None,SESSION=None,username=None):
"""upload the files"""	"""upload the files"""
	#TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
ctx2=ctx.cdliRoot	ctx2=ctx.cdliRoot

self.result+="<h2>Start processing</h2>"	self.result+="<h2>Start processing</h2>"

	#shall I only upload the changed files?
if procedure=="uploadchanged":	if procedure=="uploadchanged":

uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])	uploadFns=SESSION.get('changed',[])+SESSION.get('newPs',[])

	#or all
elif procedure=="uploadAll":	elif procedure=="uploadAll":
uploadFns=[]	uploadFns=[]
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']:
uploadFns.append(x)	uploadFns.append(x)

	#or maybe nothing
elif procedure=="noupload":	elif procedure=="noupload":
return True	return True
else:	else:
uploadFns=[]	uploadFns=[]

	#do first the changed files
for fn in uploadFns:	for fn in uploadFns:
founds=ctx2.CDLICatalog.search({'title':fn})	founds=ctx2.CDLICatalog.search({'title':fn})
if len(founds)>0:	if len(founds)>0:
Line 99 class uploadATFfinallyThread(Thread):	Line 144 class uploadATFfinallyThread(Thread):
founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=file(os.path.join(SESSION['tmpdir'],fn)))	founds[0].getObject().manage_addCDLIFileObject('',comment,SESSION['author'],file=file(os.path.join(SESSION['tmpdir'],fn)))


	#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>"	self.result+="<p>Adding files</p>"
ctx2.cdli_main.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)	#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)



#unlock	#unlock locked files?
if unlock:	if unlock:
self.result+="<p>Unlock files</p>"	self.result+="<p>Unlock files</p>"
unlockFns=[]	unlockFns=[]
Line 123 class uploadATFfinallyThread(Thread):	Line 170 class uploadATFfinallyThread(Thread):

founds[0].getObject().lockedBy=""	founds[0].getObject().lockedBy=""

	#if a basketname is give, add files to the basket
if not (basketname ==''):	if not (basketname ==''):
self.result+="<p>Add basket</p>"	self.result+="<p>Add basket</p>"
basketId=ctx2.basketContainer.getBasketIdfromName(basketname)	basketId=ctx2.basketContainer.getBasketIdfromName(basketname)
Line 142 class uploadATFfinallyThread(Thread):	Line 190 class uploadATFfinallyThread(Thread):
return True	return True

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

def __init__(self):	def __init__(self):
	"""initialise"""

self.continueVar=True	self.continueVar=True
self.returnValue=None	self.returnValue=None

Line 151 class uploadATFThread(Thread):	Line 202 class uploadATFThread(Thread):


def set(self,upload,basketId,username,serverport="8080"):	def set(self,upload,basketId,username,serverport="8080"):
	"""set start values for the thread"""
self.result=""	self.result=""
self.upload=upload	self.upload=upload
self.basketId=basketId	self.basketId=basketId
Line 158 class uploadATFThread(Thread):	Line 210 class uploadATFThread(Thread):
self.serverport=serverport	self.serverport=serverport

def __call__(self):	def __call__(self):
"""wait"""	"""call method """
self.run()	self.run()
return True	return True

def getContext(self, app,serverport="8080"):	def getContext(self, app,serverport="8080"):
	"""get the context within the ZODB"""
resp = HTTPResponse(stdout=None)	resp = HTTPResponse(stdout=None)
env = {	env = {
'SERVER_NAME':'localhost',	'SERVER_NAME':'localhost',
Line 175 class uploadATFThread(Thread):	Line 228 class uploadATFThread(Thread):
def run(self):	def run(self):

self.result=""	self.result=""
	#find context within ZODB
from Zope import DB	from Zope import DB
conn = DB.open()	conn = DB.open()
root = conn.root()	root = conn.root()
Line 182 class uploadATFThread(Thread):	Line 236 class uploadATFThread(Thread):
ctx = self.getContext(app,serverport=self.serverport)	ctx = self.getContext(app,serverport=self.serverport)
self.uploadATFThread(ctx,self.upload,self.basketId)	self.uploadATFThread(ctx,self.upload,self.basketId)

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

	get_transaction().commit()

while self.continueVar:	while self.continueVar:
pass	pass
get_transaction().abort()
conn.close()	conn.close()


def getResult(self):	def getResult(self):
	"""method for accessing result"""
return self.result	return self.result

def uploadATFThread(self,ctx,upload,basketId=0):	def uploadATFThread(self,ctx,upload,basketId=0):
"""upload an atf file"""	"""upload an atf file"""
#TODO: add comments	#TODO: add comments
#TODO: finish uploadATF	#TODO: finish uploadATF
self.result="<html><body><h2>I am loading your file...</h2>"	self.result="<html><body><h2>I got your file, start now to split it into single atf-files!</h2><p>"
basketId=str(basketId)

	#make sure that id is a string and not an integer
	basketId=str(basketId)

	#TODO: make this configurable, at the moment, rootFolder for cdli has to be cdliRoot
ctx2=ctx.cdliRoot	ctx2=ctx.cdliRoot

	#get temporary file for staging the downloaded and splitted files
dir=mkdtemp()	dir=mkdtemp()
changed=[]
errors=[]
newPs=[]
psNotInCatalog=[]
basketNameFromFile, numberOfFiles=splitatf(upload,dir)


	changed=[] # changed files
	errors=[] # files with errors
	newPs=[] # new p filed
	psNotInCatalog=[] # files not in the catalog

	#split the uploadedd atf file
	basketNameFromFile, numberOfFiles=splitatf(upload,dir,ext=self)

	#find basketId if not set

	#get active abaket
if basketId == '0':	if basketId == '0':
basketObj=ctx2.basketContainer.getActiveBasket()	basketObj=ctx2.basketContainer.getActiveBasket()
if basketObj:	if basketObj:
basketId=basketObj.getId()	basketId=basketObj.getId()

	#if there is no active baske and no basketid given, id is empty, else get besketname and length
if basketId == '0':	if basketId == '0':
basketNameFromId=""	basketNameFromId=""
basketLen=0	basketLen=0
Line 220 class uploadATFThread(Thread):	Line 291 class uploadATFThread(Thread):
basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()	basketLen=getattr(ctx2.basketContainer,basketId).getLastVersion().numberOfItems()


self.result+="<html><body><h2>I got the files</h2><p>I am checking now the files</p>"	self.result+="""<html><body><h2>I got the files</h2><
	p>I am computing the differences to the exisiting files</p>"""

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

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

	# check if file is in the catalog
	#TODO: checkCatalog is not implemented yet
if ctx2.cdli_main.checkCatalog(fn):	if ctx2.cdli_main.checkCatalog(fn):
psNotInCatalog.append(fn)	psNotInCatalog.append(fn)

	#check if p-file already at the server
founds=ctx2.CDLICatalog.search({'title':fn})	founds=ctx2.CDLICatalog.search({'title':fn})

	#if not than add filename to the list of newfiles
if len(founds)==0:	if len(founds)==0:
newPs.append(fn)	newPs.append(fn)

	#if p file alread at the server
for found in founds:	for found in founds:
	#analyse the differences to the actual file
obj=found.getObject()	obj=found.getObject()

if (not obj.lockedBy=='') and (not obj.lockedBy==self.username):	if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(self.username))):
errors.append(obj)	errors.append(obj)
else:	else:
data=file(os.path.join(dir,fn)).read()	data=file(os.path.join(dir,fn)).read()
Line 247 class uploadATFThread(Thread):	Line 325 class uploadATFThread(Thread):
changed.append((obj,diffs))	changed.append((obj,diffs))
#hochladen	#hochladen

	#ready, set the returnValues
self.result+="<h3>Done</h3></body></html>"	self.result+="<h3>Done</h3></body></html>"

self.returnValue={}	self.returnValue={}
Line 389 class BasketObject_old(Folder):	Line 467 class BasketObject_old(Folder):

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

	return num

def addObjects(self,ids):	def addObjects(self,ids):
"""addObjects"""	"""addObjects"""
Line 503 class CDLIBasketContainer(OrderedFolder)	Line 583 class CDLIBasketContainer(OrderedFolder)
security=ClassSecurityInfo()	security=ClassSecurityInfo()
meta_type="CDLIBasketContainer"	meta_type="CDLIBasketContainer"

	def upDateBaskets(self):
	"""update content in to objects"""

	founds=self.ZopeFind(self,obj_metatypes=['CDLIBasketVersion'],search_sub=1)

	for found in founds:
	found[1].updateBasket()

	security.declareProtected('manage','deleteBaskets')
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"""

Line 520 class CDLIBasketContainer(OrderedFolder)	Line 609 class CDLIBasketContainer(OrderedFolder)
cut=self.manage_cutObjects(ids)	cut=self.manage_cutObjects(ids)
trash.manage_pasteObjects(cut)	trash.manage_pasteObjects(cut)

	security.declareProtected('manage','manageBaskets')
def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):	def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):
"""manage baskets, delete or copy"""	"""manage baskets, delete or copy"""
if submit=="delete":	if submit=="delete":
Line 529 class CDLIBasketContainer(OrderedFolder)	Line 619 class CDLIBasketContainer(OrderedFolder)

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

	security.declareProtected('View','getBasketIdfromName')
def getBasketIdfromName(self,basketname):	def getBasketIdfromName(self,basketname):
"""get id from name"""	"""get id from name"""

Line 554 class CDLIBasketContainer(OrderedFolder)	Line 646 class CDLIBasketContainer(OrderedFolder)
return pt(basketId=basketId,basketName=basketName)	return pt(basketId=basketId,basketName=basketName)


	security.declareProtected('View','index_html')
def index_html(self):	def index_html(self):
"""stanadard ansicht"""	"""stanadard ansicht"""

Line 724 class CDLIBasket(Folder,CatalogAware):	Line 816 class CDLIBasket(Folder,CatalogAware):
meta_type="CDLIBasket"	meta_type="CDLIBasket"
default_catalog="CDLIBasketCatalog"	default_catalog="CDLIBasketCatalog"


def getFile(self,obj):	def getFile(self,obj):
return obj[1]	return obj[1]

Line 735 class CDLIBasket(Folder,CatalogAware):	Line 828 class CDLIBasket(Folder,CatalogAware):

return [x[1].getId() for x in self.getLastVersion().getContent()]	return [x[1].getId() for x in self.getLastVersion().getContent()]


def isActual(self,obj):	def isActual(self,obj):
"""teste ob im basket die aktuelle version ist"""	"""teste ob im basket die aktuelle version ist"""
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()})	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":	if len(founds)>0 and founds[0].getObject().aq_parent.getId()==".trash":
return False, -1	return False, -1

Line 775 class CDLIBasket(Folder,CatalogAware):	Line 872 class CDLIBasket(Folder,CatalogAware):

def getLastVersion(self):	def getLastVersion(self):
"""hole letzte version"""	"""hole letzte version"""
ids=[int(x[0]) for x in self.ZopeFind(self,obj_metatypes=["CDLIBasketVersion"])]
	ids=[]
	idsTmp= self.objectIds()
	for x in idsTmp:
	try:
	ids.append(int(x))
	except:
	pass
ids.sort()	ids.sort()

if len(ids)==0:	if len(ids)==0:
return None	return None
else:	else:
ob=getattr(self,str(ids[-1]))	ob=getattr(self,str(ids[-1]))


return ob	return ob

def getVersions(self):	def getVersions(self):
Line 789 class CDLIBasket(Folder,CatalogAware):	Line 896 class CDLIBasket(Folder,CatalogAware):
return versions	return versions


	def updateObjects(self,ids,RESPONSE=None,REQUEST=None):
	"""update ids, ids not in the basket the add"""
	if type(ids) is not ListType:
	ids=[ids]

	lastVersion=self.getLastVersion()
	oldContent=lastVersion.content.getContent()
	newContent=[]

	#first copy the old
	for obj in oldContent:
	if obj[1].getId() not in ids:
	newContent.append(obj)
	#now add the new

	for id in ids:
	founds=self.CDLICatalog.search({'title':id})

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


	content=newContent
	user=self.getActualUserName()

	ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=newContent)

	obj=self._getOb(ob.getId())
	if RESPONSE:

	RESPONSE.redirect(obj.absolute_url())

	return obj

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"""
Line 798 class CDLIBasket(Folder,CatalogAware):	Line 940 class CDLIBasket(Folder,CatalogAware):
if lastVersion is None:	if lastVersion is None:
oldContent=[]	oldContent=[]
else:	else:
oldContent=lastVersion.basketContent[0:]	oldContent=lastVersion.content.getContent()

if deleteOld:	if deleteOld:
oldContent=[]	oldContent=[]
Line 824 class CDLIBasket(Folder,CatalogAware):	Line 966 class CDLIBasket(Folder,CatalogAware):

return added	return added

	def changeBasket(self,ids,submit,RESPONSE=None,REQUEST=None):
	"""change a basket"""
	if submit=="update":
	return self.updateObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)
	elif submit=="delete":
	return self.deleteObjects(ids,RESPONSE=RESPONSE,REQUEST=REQUEST)

def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):	def deleteObjects(self,ids,RESPONSE=None,REQUEST=None):
"""delete objects"""	"""delete objects"""

Line 831 class CDLIBasket(Folder,CatalogAware):	Line 980 class CDLIBasket(Folder,CatalogAware):
ids=[ids]	ids=[ids]

lastVersion=self.getLastVersion()	lastVersion=self.getLastVersion()
oldContent=lastVersion.basketContent[0:]	oldContent=lastVersion.content.getContent()
newContent=[]	newContent=[]
for obj in oldContent:	for obj in oldContent:
if obj[1].getId() not in ids:	if obj[1].getId() not in ids:
Line 865 def manage_addCDLIBasket(self,title,shor	Line 1014 def manage_addCDLIBasket(self,title,shor
else:	else:
return ob	return ob

class CDLIBasketVersion(SimpleItem):	class CDLIBasketVersion(Implicit,Persistent,Folder):
"""version of a basket"""	"""version of a basket"""

meta_type="CDLIBasketVersion"	meta_type="CDLIBasketVersion"
	security=ClassSecurityInfo()

def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):	def updateBasket(self):
	"""update"""
	try:
	self._setObject('content',BasketContent(self.basketContent))
	except:
	try:
	if len(self.basketContent)>0:
	self.content.setContent(self.basketContent)
	except:
	print "error",self.getId(),self.aq_parent.getId()
	self.basketContent=[]


	def containsNonActualFiles(self):
	"""returns True if basket contains one or more non current files"""

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

	security.declareProtected('View','downloadObjectsAsOneFile')
	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"""

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

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

Line 885 class CDLIBasketVersion(SimpleItem):	Line 1062 class CDLIBasketVersion(SimpleItem):

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

if not object[1].lockedBy=="":	if not object[1].lockedBy=="":
lockedObjects[object[1].title]=repr(object[1].lockedBy)	lockedObjects[object[1].title]=repr(object[1].lockedBy)
Line 903 class CDLIBasketVersion(SimpleItem):	Line 1080 class CDLIBasketVersion(SimpleItem):
procedure="downloadAll"	procedure="downloadAll"


for object in self.basketContent:	for object in self.content.getContent():

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

if lock and object[1].lockedBy=='':	if lock and object[1].lockedBy=='':
object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']	object[1].lockedBy=self.REQUEST['AUTHENTICATED_USER']
Line 925 class CDLIBasketVersion(SimpleItem):	Line 1108 class CDLIBasketVersion(SimpleItem):

def numberOfItems(self):	def numberOfItems(self):
"""return anzahl der elemente im basket"""	"""return anzahl der elemente im basket"""
return len(self.basketContent)	return self.content.numberOfItems()

def getTime(self):	def getTime(self):
"""getTime"""	"""getTime"""
Line 941 class CDLIBasketVersion(SimpleItem):	Line 1124 class CDLIBasketVersion(SimpleItem):

def getContent(self):	def getContent(self):
"""get Basket Content"""	"""get Basket Content"""
return self.basketContent	return self.content.getContent()


def __init__(self,id,user,comment="",basketContent=[]):	def __init__(self,id,user,comment="",basketContent=[]):
""" init a basket version"""	""" init a basket version"""
self.id=id	self.id=id
self.coment=comment	self.coment=comment
self.basketContent=basketContent[0:]	self._setObject('content',BasketContent(basketContent))
	#self.basketContent=basketContent[0:]a
self.user=user	self.user=user
self.time=time.localtime()	self.time=time.localtime()

Line 960 class CDLIBasketVersion(SimpleItem):	Line 1144 class CDLIBasketVersion(SimpleItem):
"""get Comment"""	"""get Comment"""
return self.comment	return self.comment

	security.declareProtected('View','index_html')
def index_html(self):	def index_html(self):
"""view the basket"""	"""view the basket"""

	if self.REQUEST.get('change',False):
	ob=self.aq_parent.updateObjects(self.REQUEST['change'])

	self.REQUEST.RESPONSE.redirect(ob.absolute_url())#go to new basket, because changing generates a new basket

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

Line 997 def manage_addCDLIBasketVersion(self,use	Line 1188 def manage_addCDLIBasketVersion(self,use
else:	else:
return ob	return ob

class CDLIFileObject(versionedFileObject):	class CDLIFileObject(CatalogAware,versionedFileObject):
"""CDLI file object"""	"""CDLI file object"""

meta_type="CDLI File Object"	meta_type="CDLI File Object"
	default_catalog='CDLIObjectsCatalog'

security=ClassSecurityInfo()	security=ClassSecurityInfo()


	security.declarePublic('makeThisVersionCurrent')

	def PrincipiaSearchSource(self):
	"""Return cataloguable key for ourselves."""
	return str(self)

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

	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','makeThisVersionCurrent.zpt')).__of__(self)
	return pt()
	def makeThisVersionCurrent(self,comment,author,RESPONSE=None):
	"""copy this version to current"""
	parent=self.aq_parent


	newversion=parent.manage_addCDLIFileObject('',comment,author)
	newversion.data=self.data[0:]

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


	return True

	security.declarePublic('view')

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

	security.declarePublic('getPNumber')
	def getPNumber(self):
	"""get the pnumber"""
	try:
	txt=re.match("&[Pp](\d)\s=([^\r\n]*)",self.data[0:])
	except:
	txt=self.data[0:]

	return "ERROR"
	try:
	return "P"+txt.group(1)
	except:
	return "ERROR"

security.declarePublic('getDesignation')	security.declarePublic('getDesignation')
def getDesignation(self):	def getDesignation(self):
"""get the designation out of the file"""	"""get the designation out of the file"""
Line 1063 class CDLIFile(versionedFile,CatalogAwar	Line 1297 class CDLIFile(versionedFile,CatalogAwar
meta_type="CDLI file"	meta_type="CDLI file"
default_catalog='CDLICatalog'	default_catalog='CDLICatalog'

	#security.declarePublic('history')
	def history(self):
	"""history"""

	ext=self.ZopeFind(self.aq_parent,obj_ids=["history_template.html"])
	if ext:
	return getattr(self,ext[0][1].getId())()

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


	def getBasketFromId(self,basketid, context=None):
	"""get basket from id"""

	if not context:
	context=self

	for basket in self.ZopeFind(context,obj_metatypes=["CDLIBasket"]):
	if basket[0]==basketid:
	return basket[1]
	else:
	None


def isContainedInBaskets(self,context=None):	def isContainedInBaskets(self,context=None):
Line 1096 class CDLIFile(versionedFile,CatalogAwar	Line 1353 class CDLIFile(versionedFile,CatalogAwar
else:	else:
return "Sorry file is locked by somebody else"	return "Sorry file is locked by somebody else"

def manage_addCDLIFileObject(self,id,vC,author,file='',title='',precondition='', content_type='',changeName='no',newName='', RESPONSE=None):	def manage_addCDLIFileObject(self,id,vC,author,
	file='',title='',
	precondition='',
	content_type='',
	changeName='no',newName='',
	come_from=None,RESPONSE=None):
"""add"""	"""add"""
try: #TODO: der ganze vC unsinn muss ueberarbeitet werden	try: #TODO: der ganze vC unsinn muss ueberarbeitet werden
vC=self.REQUEST['vC']	vC=self.REQUEST['vC']
Line 1118 class CDLIFile(versionedFile,CatalogAwar	Line 1380 class CDLIFile(versionedFile,CatalogAwar




positionVersionNum=getattr(self,'positionVersionNum','front')	positionVersionNum=getattr(self,'positionVersionNum','front')

if positionVersionNum=='front':	if positionVersionNum=='front':
Line 1133 class CDLIFile(versionedFile,CatalogAwar	Line 1394 class CDLIFile(versionedFile,CatalogAwar

manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)	manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)
objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))	objs=self.ZopeFind(self,obj_ids=[id])[0][1].setVersionNumber(int(self.getVersion()))
	try:
	#FIXME: wozu ist das gut?
self.REQUEST.SESSION['objID_parent']=self.getId()	self.REQUEST.SESSION['objID_parent']=self.getId()
	except:
	pass

if RESPONSE:	if RESPONSE:

obj=self.ZopeFind(self,obj_ids=[id])[0][1]	obj=self.ZopeFind(self,obj_ids=[id])[0][1]
if obj.getSize()==0:	if obj.getSize()==0:
self.REQUEST.SESSION['objID']=obj.getId()	self.REQUEST.SESSION['objID']=obj.getId()
Line 1143 class CDLIFile(versionedFile,CatalogAwar	Line 1409 class CDLIFile(versionedFile,CatalogAwar
return pt()	return pt()

else:	else:
	if come_from and (come_from!=""):
	RESPONSE.redirect(come_from+"?change="+self.getId())
	else:
RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)	RESPONSE.redirect(self.REQUEST['URL2']+'?uploaded=%s'%self.title)

else:	else:
Line 1157 def manage_addCDLIFileForm(self):	Line 1426 def manage_addCDLIFileForm(self):
def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):	def manage_addCDLIFile(self,id,title,lockedBy, author=None, RESPONSE=None):
"""add the OSAS_root"""	"""add the OSAS_root"""
newObj=CDLIFile(id,title,lockedBy,author)	newObj=CDLIFile(id,title,lockedBy,author)

	tryToggle=True
	tryCount=0



self._setObject(id,newObj)	self._setObject(id,newObj)


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




def splitatf(fh,dir=None):	def splitatf(fh,dir=None,ext=None):
"""split it"""	"""split it"""
ret=None	ret=None
nf=None	nf=None
	i=0
for line in fh.readlines():	for line in fh.readlines():
	if ext:
	i+=1
	if (i%100)==0:
	ext.result+="."
	if i==10000:
	i=0
	ext.result+="<br>"
#check if basket name is in the first line	#check if basket name is in the first line
if line.find("#atf basket")>=0:	if line.find("#atf basket")>=0:
ret=line.replace('#atf basket ','')	ret=line.replace('#atf basket ','')
Line 1200 class CDLIFileFolder(versionedFileFolder	Line 1484 class CDLIFileFolder(versionedFileFolder
filesMetaType=['CDLI file']	filesMetaType=['CDLI file']
folderMetaType=['CDLI Folder']	folderMetaType=['CDLI Folder']
default_catalog='CDLICatalog'	default_catalog='CDLICatalog'
	defaultFileCatalog=default_catalog #wenn dieses definiert ist, wird beim hinzuf�gen einer neuen version eines files dieser catalog neuiniziert

	tmpStore2={}
def setTemp(self,name,value):	def setTemp(self,name,value):
"""set tmp"""	"""set tmp"""

Line 1241 class CDLIFileFolder(versionedFileFolder	Line 1527 class CDLIFileFolder(versionedFileFolder
"""check if fn is in the catalog"""	"""check if fn is in the catalog"""
#TODO add checkCatalog	#TODO add checkCatalog

def refreshTxt(self,txt=""):
"""txt fuer refresh"""

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


def getResult(self):
"""result of thread"""
try:
return self._v_uploadATF.getResult()
except:
return "One moment, please"

def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
"""standard ausgabe"""
#self._v_uploadATF.returnValue=None

threadName=repeat
if not threadName or threadName=="":
tmpVar=False

self._v_uploadATF=uploadATFThread()

#self._xmltrans.start()
#thread=Thread(target=self._v_uploadATF)

self._v_uploadATF.set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
#thread.start()
self._v_uploadATF.start()


self.threadName=self._v_uploadATF.getName()[0:]	def findObjectsFromListWithVersion(self,list):
wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])	"""find objects from a list with versions
	@param list: list of tuples (cdliFile,version)
if wait_template:	"""
return wait_template[0][1]()
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
return pt(txt='/uploadATF')
#_v_xmltrans.run()

else:

if not self._v_uploadATF.returnValue:


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','uploadATFWait.zpt')).__of__(self)

return pt(txt='/uploadATF')

else:

tmp=self._v_uploadATF.returnValue
self._v_uploadATF.continueVar=False

self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]
self.REQUEST.SESSION['errors']=[x.getId() for x in tmp['errors']]
self.REQUEST.SESSION['newPs']=tmp['newPs']
self.REQUEST.SESSION['tmpdir']=tmp['dir']

pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])

def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
"""nowupload the files"""



threadName=repeat
if not threadName or threadName=="":


self._v_uploadATF=uploadATFfinallyThread()


self._v_uploadATF.set(procedure,comment=comment,basketname=basketname,unlock=unlock,SESSION=self.REQUEST.SESSION,username=self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])

self._v_uploadATF.start()


self.threadName=self._v_uploadATF.getName()[0:]
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','uploadATFWait.zpt')).__of__(self)

return pt(txt='/uploadATFfinally')
#_v_xmltrans.run()

else:

if hasattr(self,'_v_uploadATF') and (self._v_uploadATF is not None) and (not self._v_uploadATF.end) :	#self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
	#self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']

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','uploadATFWait.zpt')).__of__(self)	pt=getattr(self,'filelistVersioned.html')
return pt(txt='/uploadATFfinally')
else:

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

	return pt(search=list)



def findObjectsFromList(self,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)"""


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

	if enterList:
	txt=enterList

	if upload or enterList:
txt=txt.replace(",","\n")	txt=txt.replace(",","\n")
txt=txt.replace("\t","\n")	txt=txt.replace("\t","\n")
txt=txt.replace("\r","\n")	txt=txt.replace("\r","\n")
Line 1385 class CDLIFileFolder(versionedFileFolder	Line 1583 class CDLIFileFolder(versionedFileFolder
if list is not None: # got already a list	if list is not None: # got already a list
ret=[]	ret=[]
for fileId in list:	for fileId in list:
if len(fileId.split("."))==1:	if fileId.find("*"): #check for wildcards
	fileId=fileId
	elif len(fileId.split("."))==1:
fileId=fileId+".atf"	fileId=fileId+".atf"

ret+=self.CDLICatalog({'title':fileId})	ret+=self.CDLICatalog({'title':fileId})
#TODO: get rid of one of these..	#TODO: get rid of one of these..
self.REQUEST.SESSION['fileIds']=[x.getObject().getId() for x in ret]#store fieldIds in session for further usage	ids=[x.getObject().getId() for x in ret]
	self.REQUEST.SESSION['fileIds']=ids#store fieldIds in session for further usage
self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']	self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']

	if display:
	pt=getattr(self,'filelist.html')

	return pt(search=ids)
	else:
return ret	return ret



if start:	if start:
RESPONSE.redirect("filelist.html?start:int="+str(start))	RESPONSE.redirect("filelist.html?start:int="+str(start))

Line 1466 class CDLIFileFolder(versionedFileFolder	Line 1675 class CDLIFileFolder(versionedFileFolder
len(getattr(self,self.default_catalog)({'path':folder[0]}))	len(getattr(self,self.default_catalog)({'path':folder[0]}))
))	))
return ret	return ret
	security.declareProtected('View','index_html')
def index_html(self):	def index_html(self):
"""main"""	"""main"""
ext=self.ZopeFind(self,obj_ids=["index.html"])	ext=self.ZopeFind(self,obj_ids=["index.html"])
Line 1476 class CDLIFileFolder(versionedFileFolder	Line 1685 class CDLIFileFolder(versionedFileFolder
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','CDLIFileFolderMain')).__of__(self)
return pt()	return pt()


	manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())


	def manage_addCDLIFileFolder(self, id, title='',
	createPublic=0,
	createUserF=0,
	REQUEST=None):
	"""Add a new Folder object with id id.

	If the 'createPublic' and 'createUserF' parameters are set to any true
	value, an 'index_html' and a 'UserFolder' objects are created respectively
	in the new folder.
	"""
	ob=CDLIFileFolder()
	ob.id=str(id)
	ob.title=title
	self._setObject(id, ob)
	ob=self._getOb(id)

	checkPermission=getSecurityManager().checkPermission

	if createUserF:
	if not checkPermission('Add User Folders', ob):
	raise Unauthorized, (
	'You are not authorized to add User Folders.'
	)
	ob.manage_addUserFolder()


	if REQUEST is not None:
	return self.manage_main(self, REQUEST, update_menu=1)

	class CDLIRoot(Folder):
	"""main folder for cdli"""

	meta_type="CDLIRoot"

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

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


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

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

	def getChangesByAuthor(self,author,n=100):
	"""getChangesByAuthor"""
	zcat=self.CDLIObjectsCatalog
	res=zcat({'lastEditor':author,
	'sort_on':'getTime',
	'sort_order':'descending',
	'sort_limit':n})[:n ]

	return res

	def getChangesByAuthor_html(self,author,n=100):
	"""html output for changes by author"""
	tmp={}
	list=[]
	for x in self.getChangesByAuthor(author):
	nr=x.getObject().getVersionNumber()
	id=x.getObject().aq_parent.getId()
	#hinzufuegen, wenn Version neuer als die
	if tmp.get(id,(0,0))[1] < nr:
	tmp[id]=(x.getObject().aq_parent,nr)


	return self.cdli_main.findObjectsFromListWithVersion(list=tmp.values())

	def getLastChanges(self,n=100):
	"""get the last n changes"""
	n=int(n)
	zcat=self.CDLICatalog
	return zcat({'sort_on':'getLastChangeDate',
	'sort_order':'descending',
	'sort_limit':n})[:n ]


	def getLastChanges_html(self,n=100):
	"""get the last n changes"""
	list = [x.getId for x in self.getLastChanges(n)]
	return self.cdli_main.findObjectsFromList(list=list,display=True)

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

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


	def getResult(self,threadName=None):
	"""result of thread"""
	try:
	return self._v_uploadATF[threadName].getResult()
	except:
	return "One moment, please"


	def checkThreads(self):
	"""check threads"""
	ret="<html><body>"
	for thread in threading.enumerate():
	ret+="<p>%s : %s</p>"%(repr(thread),thread.isAlive())

	return ret



	def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
	"""standard ausgabe"""
	#self._v_uploadATF.returnValue=None

	threadName=repeat
	if not threadName or threadName=="":
	tmpVar=False

	thread=uploadATFThread()
	threadName=thread.getName()[0:]
	if (not hasattr(self,'_v_uploadATF')):
	self._v_uploadATF={}

	self._v_uploadATF[threadName]=thread
	#self._xmltrans.start()
	#thread=Thread(target=self._v_uploadATF)

	self._v_uploadATF[threadName].set(upload,basketId,self.REQUEST['AUTHENTICATED_USER'],serverport=self.REQUEST['SERVER_PORT'])
	#thread.start()
	self._v_uploadATF[threadName].start()


	self.threadName=self._v_uploadATF[threadName].getName()[0:]
	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','uploadATFWait.zpt')).__of__(self)
	return pt(txt='/uploadATF',threadName=threadName)
	#_v_xmltrans.run()

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

	if not self._v_uploadATF[threadName].returnValue:


	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','uploadATFWait.zpt')).__of__(self)

	return pt(txt='/uploadATF',threadName=threadName)

	else:
	# tmp={}
	# for key in self._v_uploadATF[threadName].returnValue.keys():
	# t=self._v_uploadATF[threadName].returnValue[key]
	# if type(t) is ListType:
	# tmp[key]=self._v_uploadATF[threadName].returnValue[key][0:]
	# else:
	# tmp[key]=self._v_uploadATF[threadName].returnValue[key]
	# print repr(tmp[key]),repr(key)
	#
	# #
	#tmp=self.cdli_main.tmpStore2[threadName]
	tmp=self._v_uploadATF[threadName].returnValue

	#self._v_uploadATF[threadName].continueVar=False

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


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

	return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
	basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])

	def redoUpload(self,threadName):
	"""redo the upload"""
	tmp=self.cdli_main.tmpStore2[threadName]
	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
	return pt(changed=tmp['changed'],errors=tmp['errors'],dir=tmp['dir'],newPs=tmp['newPs'],basketLen=tmp['basketLen'],numberOfFiles=tmp['numberOfFiles'],
	basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])

	def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
	"""nowupload the files"""



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

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


	self._v_uploadATF[threadName]=thread


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

	self._v_uploadATF[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','uploadATFWait.zpt')).__of__(self)

	return pt(txt='/uploadATFfinally',threadName=threadName)
	#_v_xmltrans.run()

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

	if self._v_uploadATF.get(threadName,None) and (self._v_uploadATF[threadName] is not None) and (not self._v_uploadATF[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','uploadATFWait.zpt')).__of__(self)
	return pt(txt='/uploadATFfinally',threadName=threadName)
	else:

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

def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):	def importFiles(self,comment="",author="" ,folderName="/Users/dwinter/Documents/workspace/cdli/atf", files=None,ext=None):
"""import files"""	"""import files"""
	root=self.cdli_main

if not files:	if not files:
files=os.listdir(folderName)	files=os.listdir(folderName)
Line 1485 class CDLIFileFolder(versionedFileFolder	Line 1955 class CDLIFileFolder(versionedFileFolder
for f in files:	for f in files:
folder=f[0:3]	folder=f[0:3]
f2=f[0:5]	f2=f[0:5]
obj=self.ZopeFind(self,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
if not obj:	if not obj:
manage_addCDLIFileFolder(self,folder,folder)	manage_addCDLIFileFolder(root,folder,folder)
fobj=getattr(self,folder)	fobj=getattr(root,folder)
	#get_transaction().commit()
else:	else:
fobj=obj[0][1]	fobj=obj[0][1]

Line 1519 class CDLIFileFolder(versionedFileFolder	Line 1989 class CDLIFileFolder(versionedFileFolder

return "ok"	return "ok"

manage_addCDLIFileFolderForm=DTMLFile('dtml/folderAdd', globals())

	manage_addCDLIRootForm=DTMLFile('dtml/rootAdd', globals())

def manage_addCDLIFileFolder(self, id, title='',
	def manage_addCDLIRoot(self, id, title='',
createPublic=0,	createPublic=0,
createUserF=0,	createUserF=0,
REQUEST=None):	REQUEST=None):
Line 1532 def manage_addCDLIFileFolder(self, id, t	Line 2003 def manage_addCDLIFileFolder(self, id, t
value, an 'index_html' and a 'UserFolder' objects are created respectively	value, an 'index_html' and a 'UserFolder' objects are created respectively
in the new folder.	in the new folder.
"""	"""
ob=CDLIFileFolder()	ob=CDLIRoot()
ob.id=str(id)	ob.id=str(id)
ob.title=title	ob.title=title
self._setObject(id, ob)	self._setObject(id, ob)

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

Removed from v.1.19
changed lines
	Added in v.1.44