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.22 and 1.37

version 1.22, 2006/06/14 18:43:38	version 1.37, 2006/07/14 19:08:30
Line 214 class uploadATFThread(Thread):	Line 214 class uploadATFThread(Thread):
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)	self.uploadATFThread(ctx,self.upload,self.basketId)
ctx.cdliRoot.cdli_main.tmpStore=self.returnValue
	#ctx.cdliRoot.cdli_main.tmpStore2[self.getName()[0:]]=self.returnValue

get_transaction().commit()	get_transaction().commit()

while self.continueVar:	while self.continueVar:
Line 231 class uploadATFThread(Thread):	Line 233 class uploadATFThread(Thread):
"""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>"

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

Line 248 class uploadATFThread(Thread):	Line 251 class uploadATFThread(Thread):
psNotInCatalog=[] # files not in the catalog	psNotInCatalog=[] # files not in the catalog

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

#find basketId if not set	#find basketId if not set

Line 267 class uploadATFThread(Thread):	Line 270 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	#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	# check if file is in the catalog
#TODO: checkCatalog is not implemented yet	#TODO: checkCatalog is not implemented yet
Line 291 class uploadATFThread(Thread):	Line 295 class uploadATFThread(Thread):
#analyse the differences to the actual file	#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 556 class CDLIBasketContainer(OrderedFolder)	Line 560 class CDLIBasketContainer(OrderedFolder)
security=ClassSecurityInfo()	security=ClassSecurityInfo()
meta_type="CDLIBasketContainer"	meta_type="CDLIBasketContainer"

	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 573 class CDLIBasketContainer(OrderedFolder)	Line 578 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 582 class CDLIBasketContainer(OrderedFolder)	Line 588 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 607 class CDLIBasketContainer(OrderedFolder)	Line 615 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 685 class CDLIBasketContainer(OrderedFolder)	Line 693 class CDLIBasketContainer(OrderedFolder)
baskets.sort(sortAuthor)	baskets.sort(sortAuthor)
elif sortField=='comment':	elif sortField=='comment':
baskets.sort(sortComment)	baskets.sort(sortComment)
	print "got the baskets"
return baskets	return baskets


Line 788 class CDLIBasket(Folder,CatalogAware):	Line 796 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 842 class CDLIBasket(Folder,CatalogAware):	Line 854 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.basketContent[0:]
	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)

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

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 877 class CDLIBasket(Folder,CatalogAware):	Line 921 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 922 class CDLIBasketVersion(SimpleItem):	Line 973 class CDLIBasketVersion(SimpleItem):
"""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 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 959 class CDLIBasketVersion(SimpleItem):	Line 1025 class CDLIBasketVersion(SimpleItem):
for object in self.basketContent:	for object in self.basketContent:

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 1013 class CDLIBasketVersion(SimpleItem):	Line 1085 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):

	self.aq_parent.updateObjects(self.REQUEST['change'])

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 1050 def manage_addCDLIBasketVersion(self,use	Line 1128 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)
Line 1116 class CDLIFile(versionedFile,CatalogAwar	Line 1223 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 isContainedInBaskets(self,context=None):	def isContainedInBaskets(self,context=None):
Line 1149 class CDLIFile(versionedFile,CatalogAwar	Line 1267 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 1171 class CDLIFile(versionedFile,CatalogAwar	Line 1294 class CDLIFile(versionedFile,CatalogAwar




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

if positionVersionNum=='front':	if positionVersionNum=='front':
Line 1191 class CDLIFile(versionedFile,CatalogAwar	Line 1313 class CDLIFile(versionedFile,CatalogAwar
self.REQUEST.SESSION['objID_parent']=self.getId()	self.REQUEST.SESSION['objID_parent']=self.getId()
except:	except:
pass	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 1199 class CDLIFile(versionedFile,CatalogAwar	Line 1323 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 1220 def manage_addCDLIFile(self,id,title,loc	Line 1347 def manage_addCDLIFile(self,id,title,loc


self._setObject(id,newObj)	self._setObject(id,newObj)
# try:
# self._setObject(id,newObj)
# tryToggle=False
# except:
# while tryToggle and (tryCount < 10):
# try:
# #get_transaction().commit()
# self._setObject(id,newObj)
# tryToggle=False
#
# except:
# time.sleep(10)
# tryCount+=1
#no successfull adding
if tryToggle:
print "ERROR",id


if RESPONSE is not None:	if RESPONSE is not None:
Line 1244 def manage_addCDLIFile(self,id,title,loc	Line 1355 def manage_addCDLIFile(self,id,title,loc



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 1279 class CDLIFileFolder(versionedFileFolder	Line 1398 class CDLIFileFolder(versionedFileFolder
filesMetaType=['CDLI file']	filesMetaType=['CDLI file']
folderMetaType=['CDLI Folder']	folderMetaType=['CDLI Folder']
default_catalog='CDLICatalog'	default_catalog='CDLICatalog'
tmpStore=None	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 1322 class CDLIFileFolder(versionedFileFolder	Line 1443 class CDLIFileFolder(versionedFileFolder



	def findObjectsFromListWithVersion(self,list):
	"""find objects from a list with versions
	@param list: list of tuples (cdliFile,version)
	"""



	#self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
	#self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']


	pt=getattr(self,'filelistVersioned.html')

	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 1356 class CDLIFileFolder(versionedFileFolder	Line 1497 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 1437 class CDLIFileFolder(versionedFileFolder	Line 1589 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 1485 class CDLIRoot(Folder):	Line 1637 class CDLIRoot(Folder):

meta_type="CDLIRoot"	meta_type="CDLIRoot"

def refreshTxt(self,txt=""):	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()
	print un
	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"""	"""txt fuer refresh"""

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


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


	def checkThreads(self):
	"""check threads"""
	return threading.enumerate()

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
Line 1505 class CDLIRoot(Folder):	Line 1720 class CDLIRoot(Folder):
threadName=repeat	threadName=repeat
if not threadName or threadName=="":	if not threadName or threadName=="":
tmpVar=False	tmpVar=False

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

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

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


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

if wait_template:	if wait_template:
return wait_template[0][1]()	return wait_template[0][1]()
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='/uploadATF')	return pt(txt='/uploadATF',threadName=threadName)
#_v_xmltrans.run()	#_v_xmltrans.run()

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

if not self._v_uploadATF.returnValue:	if 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 1540 class CDLIRoot(Folder):	Line 1762 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='/uploadATF')	return pt(txt='/uploadATF',threadName=threadName)

else:	else:
# tmp={}	# tmp={}
# for key in self._v_uploadATF.returnValue.keys():	# for key in self._v_uploadATF[threadName].returnValue.keys():
# t=self._v_uploadATF.returnValue[key]	# t=self._v_uploadATF[threadName].returnValue[key]
# if type(t) is ListType:	# if type(t) is ListType:
# tmp[key]=self._v_uploadATF.returnValue[key][0:]	# tmp[key]=self._v_uploadATF[threadName].returnValue[key][0:]
# else:	# else:
# tmp[key]=self._v_uploadATF.returnValue[key]	# tmp[key]=self._v_uploadATF[threadName].returnValue[key]
tmp=self.cdli_main.tmpStore	# 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._v_uploadATF.continueVar=False
self.REQUEST.SESSION['changed']=[x[0].getId() for x in tmp['changed']]	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['errors']=[x.getId() for x in tmp['errors']]
self.REQUEST.SESSION['newPs']=tmp['newPs']	self.REQUEST.SESSION['newPs']=tmp['newPs']
self.REQUEST.SESSION['tmpdir']=tmp['dir']	self.REQUEST.SESSION['tmpdir']=tmp['dir']
	#del(self.cdli_main.tmpStore2[threadName])
	print "here the templates"

pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadCheck.zpt')).__of__(self)
	print "init p"
	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'],	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'])	basketNameFromId=tmp['basketNameFromId'],basketNameFromFile=tmp['basketNameFromFile'],basketId=tmp['basketId'])

Line 1569 class CDLIRoot(Folder):	Line 1806 class CDLIRoot(Folder):

threadName=repeat	threadName=repeat
if not threadName or threadName=="":	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=uploadATFfinallyThread()

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

self._v_uploadATF.start()


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

if wait_template:	if wait_template:
return wait_template[0][1]()	return wait_template[0][1]()
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')	return pt(txt='/uploadATFfinally',threadName=threadName)
#_v_xmltrans.run()	#_v_xmltrans.run()

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

if hasattr(self,'_v_uploadATF') and (self._v_uploadATF is not None) and (not self._v_uploadATF.end) :	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'])	wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
if wait_template:	if wait_template:
return wait_template[0][1]()	return wait_template[0][1]()

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')	return pt(txt='/uploadATFfinally',threadName=threadName)
else:	else:

if RESPONSE is not None:	if RESPONSE is not None:
Line 1686 def manage_addCDLIRoot(self, id, title='	Line 1929 def manage_addCDLIRoot(self, id, title='
if REQUEST is not None:	if REQUEST is not None:
return self.manage_main(self, REQUEST, update_menu=1)	return self.manage_main(self, REQUEST, update_menu=1)

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

Removed from v.1.22
changed lines
	Added in v.1.37