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

version 1.23, 2006/06/14 18:50:09	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
Line 20 from ZPublisher.BaseRequest import Reque	Line 21 from ZPublisher.BaseRequest import Reque
import threading	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())


class uploadATFfinallyThread(Thread):	class uploadATFfinallyThread(Thread):
"""class for adding uploaded filed (temporarily stored in the staging area at /tmp"""	"""class for adding uploaded filed (temporarily stored in the staging area at /tmp"""
Line 214 class uploadATFThread(Thread):	Line 235 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 254 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 272 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 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	#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 316 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 442 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 556 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 573 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 582 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 607 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 777 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 788 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 828 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 842 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 851 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 877 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 884 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 918 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 938 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 956 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 978 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 994 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 1013 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 1050 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 1116 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 1149 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 1171 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 1191 class CDLIFile(versionedFile,CatalogAwar	Line 1399 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 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 1228 def manage_addCDLIFile(self,id,title,loc	Line 1441 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 1263 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'
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 1306 class CDLIFileFolder(versionedFileFolder	Line 1529 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')

def findObjectsFromList(self,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):	return pt(search=list)



	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 1340 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 1421 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 1469 class CDLIRoot(Folder):	Line 1723 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()

	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"""
	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):	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 1489 class CDLIRoot(Folder):	Line 1812 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 1524 class CDLIRoot(Folder):	Line 1854 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])


	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)	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 1553 class CDLIRoot(Folder):	Line 1898 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=uploadATFfinallyThread()	self._v_uploadATF[threadName]=thread


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].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 1606 class CDLIRoot(Folder):	Line 1958 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
if not obj:	if not obj:
manage_addCDLIFileFolder(root,folder,folder)	manage_addCDLIFileFolder(root,folder,folder)
fobj=getattr(root,folder)	fobj=getattr(root,folder)
Line 1670 def manage_addCDLIRoot(self, id, title='	Line 2022 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.23
changed lines
	Added in v.1.44