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.21 and 1.49

version 1.21, 2006/06/13 20:59:56	version 1.49, 2006/10/16 13:19:34
Line 1	Line 1
"""CDLI extensions of the filearchive"""	"""CDLI extensions of the filearchive"""
from Products.versionedFile.versionedFile import *	from Products.versionedFile.extVersionedFile import *
from Products.ZCatalog.CatalogPathAwareness import CatalogAware	from Products.ZCatalog.CatalogPathAwareness import CatalogAware
from tempfile import mkstemp,mkdtemp	from tempfile import mkstemp,mkdtemp
import os.path	import os.path
import os	import os
from types import *	from types import *
import urlparse	import urlparse
	import urllib
	import cgi
from OFS.OrderedFolder import OrderedFolder	from OFS.OrderedFolder import OrderedFolder
from OFS.SimpleItem import SimpleItem	from OFS.SimpleItem import SimpleItem
import time	import time
Line 13 from OFS.Folder import manage_addFolder	Line 15 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	import threading
global tmpVar

	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 76 class uploadATFfinallyThread(Thread):	Line 100 class uploadATFfinallyThread(Thread):
conn.close()	conn.close()
#set flag for end of this method	#set flag for end of this method
self.end=True	self.end=True
	print "ended"
return True	return True

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



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

Line 99 class uploadATFfinallyThread(Thread):	Line 129 class uploadATFfinallyThread(Thread):
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['lockerrors']:
uploadFns.append(x)	uploadFns.append(x)

#or maybe nothing	#or maybe nothing
Line 114 class uploadATFfinallyThread(Thread):	Line 144 class uploadATFfinallyThread(Thread):
if len(founds)>0:	if len(founds)>0:
SESSION['author']=str(username)	SESSION['author']=str(username)
self.result+="<p>Changing : %s"%fn	self.result+="<p>Changing : %s"%fn
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=os.path.join(SESSION['tmpdir'],fn),from_tmp=True)


#now add the new files	#now add the new files
Line 123 class uploadATFfinallyThread(Thread):	Line 153 class uploadATFfinallyThread(Thread):
tmpDir=SESSION['tmpdir']	tmpDir=SESSION['tmpdir']
self.result+="<p>Adding files</p>"	self.result+="<p>Adding files</p>"
#TODO: make this configurable, at the moment base folder for the files has to be cdli_main	#TODO: make this configurable, at the moment base folder for the files has to be cdli_main
ctx2.cdli_main.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
	ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)



Line 208 class uploadATFThread(Thread):	Line 239 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()
print "done"

def getResult(self):	def getResult(self):
"""method for accessing result"""	"""method for accessing result"""
Line 222 class uploadATFThread(Thread):	Line 257 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 235 class uploadATFThread(Thread):	Line 271 class uploadATFThread(Thread):

changed=[] # changed files	changed=[] # changed files
errors=[] # files with errors	errors=[] # files with errors
	lockerrors=[] # files with errors

newPs=[] # new p filed	newPs=[] # new p filed
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 249 class uploadATFThread(Thread):	Line 287 class uploadATFThread(Thread):
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 there is no active basket 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 258 class uploadATFThread(Thread):	Line 296 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 274 class uploadATFThread(Thread):	Line 313 class uploadATFThread(Thread):
founds=ctx2.CDLICatalog.search({'title':fn})	founds=ctx2.CDLICatalog.search({'title':fn})

#if not than add filename to the list of newfiles	#if not than add filename to the list of newfiles

	data=file(os.path.join(dir,fn)).read()
	#status,msg=checkFile(fn,data,dir)
	status=True
	msg=""
	if not status: # error
	errors.append((fn,msg))
	else:
if len(founds)==0:	if len(founds)==0:
newPs.append(fn)	newPs.append(fn)

Line 282 class uploadATFThread(Thread):	Line 329 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)	lockerrors.append(fn)
else:	else:
data=file(os.path.join(dir,fn)).read()
diffs=obj.diff(data)	diffs=obj.diff(data)
if diffs[0]>0:	if diffs[0]>0:
changed.append((obj,diffs))	changed.append((obj,diffs)) #hochladen
#hochladen

#ready, set the returnValues	#ready, set the returnValues
self.result+="<h3>Done</h3></body></html>"	self.result+="<h3>Done</h3></body></html>"
Line 297 class uploadATFThread(Thread):	Line 343 class uploadATFThread(Thread):
self.returnValue={}	self.returnValue={}
self.returnValue['changed']=changed	self.returnValue['changed']=changed
self.returnValue['errors']=errors	self.returnValue['errors']=errors
	self.returnValue['lockerrors']=lockerrors
self.returnValue['newPs']=newPs	self.returnValue['newPs']=newPs
self.returnValue['tmpdir']=dir	self.returnValue['tmpdir']=dir
self.returnValue['basketLen']=basketLen	self.returnValue['basketLen']=basketLen
Line 433 class BasketObject_old(Folder):	Line 480 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 479 class BasketObject_old(Folder):	Line 528 class BasketObject_old(Folder):
ret=""	ret=""
lockedObjects={}	lockedObjects={}

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


if lock:	if lock:

Line 505 class BasketObject_old(Folder):	Line 557 class BasketObject_old(Folder):
elif not procedure: #keine fails gesperrt dann alle donwloaden	elif not procedure: #keine fails gesperrt dann alle donwloaden
procedure="downloadAll"	procedure="downloadAll"

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


for object in self.contents:	for object in self.contents:

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

if lock and object.lockedBy=='':	if lock and object.lockedBy=='':
object.lockedBy=self.REQUEST['AUTHENTICATED_USER']	object.lockedBy=self.REQUEST['AUTHENTICATED_USER']
Line 520 class BasketObject_old(Folder):	Line 576 class BasketObject_old(Folder):
length=len(ret)	length=len(ret)
self.REQUEST.RESPONSE.setHeader("Content-Length",length)	self.REQUEST.RESPONSE.setHeader("Content-Length",length)
self.REQUEST.RESPONSE.write(ret)	self.REQUEST.RESPONSE.write(ret)
	self.temp_folder.downloadCounter-=1
	self._p_changed=1
	get_transaction().commit()


def manage_addBasket_oldObjectForm(self):	def manage_addBasket_oldObjectForm(self):
Line 547 class CDLIBasketContainer(OrderedFolder)	Line 606 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 564 class CDLIBasketContainer(OrderedFolder)	Line 632 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 573 class CDLIBasketContainer(OrderedFolder)	Line 642 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 598 class CDLIBasketContainer(OrderedFolder)	Line 669 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 620 class CDLIBasketContainer(OrderedFolder)	Line 691 class CDLIBasketContainer(OrderedFolder)
self.id=id	self.id=id
self.title=title	self.title=title

	def getBasketsId(self):
	"""get all baskets als klartext"""
	ret=""
	baskets=self.ZopeFind(self,obj_metatypes=['CDLIBasket'])
	for basket in baskets:
	com,user,time,values = basket[1].getContentIds()
	ret+= "BASKET:"+com+"\t"+user+"\t"+time+"\n"
	for x in values:
	ret+= x[0]+"\t"+x[1]+"\n"
	return ret

def getBaskets(self,sortField='title'):	def getBaskets(self,sortField='title'):
"""get all baskets files"""	"""get all baskets files"""
Line 694 class CDLIBasketContainer(OrderedFolder)	Line 775 class CDLIBasketContainer(OrderedFolder)
def setActiveBasket(self,basketId,REQUEST=None):	def setActiveBasket(self,basketId,REQUEST=None):
"""store active basketId in a cookie"""	"""store active basketId in a cookie"""
self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")	self.REQUEST.RESPONSE.setCookie("CDLIActiveBasket",basketId,path="/")
	try:
	qs=cgi.parse_qs(REQUEST['QUERY_STRING'])
	del(qs['basketId'])
	except:
	qs={}
if REQUEST:	if REQUEST:
REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+REQUEST['QUERY_STRING'])	REQUEST.RESPONSE.redirect(REQUEST['URL1']+'?'+urllib.urlencode(qs))

def getActiveBasket(self):	def getActiveBasket(self):
"""get active basket from cookie"""	"""get active basket from cookie"""
Line 768 class CDLIBasket(Folder,CatalogAware):	Line 853 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 779 class CDLIBasket(Folder,CatalogAware):	Line 865 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 819 class CDLIBasket(Folder,CatalogAware):	Line 909 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 833 class CDLIBasket(Folder,CatalogAware):	Line 933 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 842 class CDLIBasket(Folder,CatalogAware):	Line 977 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 850 class CDLIBasket(Folder,CatalogAware):	Line 985 class CDLIBasket(Folder,CatalogAware):
newContent=[]	newContent=[]
added=0	added=0
for id in ids:	for id in ids:
	try:
founds=self.CDLICatalog.search({'title':id})	founds=self.CDLICatalog.search({'title':id})
	except:
	founds=[]
for found in founds:	for found in founds:
if found.getObject() not in oldContent:	if found.getObject() not in oldContent:
#TODO: was passiert wenn, man eine Object dazuf�gt, das schon da ist aber eine neuere version	#TODO: was passiert wenn, man eine Object dazuf�gt, das schon da ist aber eine neuere version
Line 868 class CDLIBasket(Folder,CatalogAware):	Line 1005 class CDLIBasket(Folder,CatalogAware):

return added	return added

	def getContentIds(self):
	"""print basket content"""
	ret=[]
	lv=self.getLastVersion()
	for obj in lv.content.getContent():
	ret.append((obj[0].getId(),obj[1].getId()))


	return lv.getComment(),lv.getUser(),lv.getTime(),ret

	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 875 class CDLIBasket(Folder,CatalogAware):	Line 1029 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 909 def manage_addCDLIBasket(self,title,shor	Line 1063 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 self.temp_folder.downloadCounterBaskets > 10000:
	return """I am sorry, currently the server has to many requests for downloads, please come back later!"""


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

	return pt(lock=lock)

	else:

	return self.downloadObjectsAsOneFileFinally(lock=lock,procedure=procedure,REQUEST=REQUEST,current="no")

	def downloadObjectsAsOneFileFinally(self,lock=None,procedure=None,REQUEST=None,current="no"):
	"""print do the download"""

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

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

if lock:	if lock:

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

#check if a locked object exist in the basket.	#check if a locked object exist in the basket.
lockedObjects={}	lockedObjects={}
for object in self.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 941 class CDLIBasketVersion(SimpleItem):	Line 1143 class CDLIBasketVersion(SimpleItem):
if len(keys)>0 and (not procedure):	if len(keys)>0 and (not procedure):
self.REQUEST.SESSION['lockedObjects']=lockedObjects	self.REQUEST.SESSION['lockedObjects']=lockedObjects
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)

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

return pt()	return pt()

elif not procedure: #keine fails gesperrt dann alle donwloaden	elif not procedure: #keine fails gesperrt dann alle donwloaden
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].getData())+"\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().getData())+"\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']

basket_name=self.aq_parent.title+"_V"+self.getId()	basket_name=self.aq_parent.title+"_V"+self.getId()

#write basketname to header of atf file	#write basketname to header of atf file
ret="#atf basket %s\n"%basket_name+ret	ret="#basket: %s\n"%basket_name+ret

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

self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)	self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")	self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
length=len(ret)	length=len(ret)
self.REQUEST.RESPONSE.setHeader("Content-Length",length)	self.REQUEST.RESPONSE.setHeader("Content-Length",length)
self.REQUEST.RESPONSE.write(ret)	self.REQUEST.RESPONSE.write(ret)
	return True

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 985 class CDLIBasketVersion(SimpleItem):	Line 1203 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 1004 class CDLIBasketVersion(SimpleItem):	Line 1223 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 1041 def manage_addCDLIBasketVersion(self,use	Line 1267 def manage_addCDLIBasketVersion(self,use
else:	else:
return ob	return ob

class CDLIFileObject(versionedFileObject):	class CDLIFileObject(CatalogAware,extVersionedFileObject):
"""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.getData()[0:])
	except:
	txt=self.getData()[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"""
try:	try:
txt=re.match("&[Pp](\d)\s=([^\r\n]*)",self.data[0:])	txt=re.match("&[Pp](\d)\s=([^\r\n]*)",self.getData()[0:])
except:	except:
txt=self.data[0:]	txt=self.getData()[0:]

return "ERROR"	return "ERROR"
try:	try:
Line 1070 class CDLIFileObject(versionedFileObject	Line 1339 class CDLIFileObject(versionedFileObject
manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')	manage_addCDLIFileObjectForm=DTMLFile('dtml/fileAdd', globals(),Kind='CDLIFileObject',kind='CDLIFileObject', version='1')

def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',	def manage_addCDLIFileObject(self,id,vC='',author='', file='',title='',precondition='', content_type='',
REQUEST=None):	from_tmp=False,REQUEST=None):
"""Add a new File object.	"""Add a new File object.

Creates a new File object 'id' with the contents of 'file'"""	Creates a new File object 'id' with the contents of 'file'"""
Line 1091 def manage_addCDLIFileObject(self,id,vC=	Line 1360 def manage_addCDLIFileObject(self,id,vC=

setattr(self._getOb(id),'author',author)	setattr(self._getOb(id),'author',author)


# Now we "upload" the data. By doing this in two steps, we	# Now we "upload" the data. By doing this in two steps, we
# can use a database trick to make the upload more efficient.	# can use a database trick to make the upload more efficient.
if file:
	if file and not from_tmp:
self._getOb(id).manage_upload(file)	self._getOb(id).manage_upload(file)
	elif file and from_tmp:
	self._getOb(id).manage_upload_from_tmp(file)
if content_type:	if content_type:
self._getOb(id).content_type=content_type	self._getOb(id).content_type=content_type

	self.reindex_object()
	self._getOb(id).reindex_object()

if REQUEST is not None:	if REQUEST is not None:
REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')	REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')

class CDLIFile(versionedFile,CatalogAware):	class CDLIFile(extVersionedFile,CatalogAware):
"""CDLI file"""	"""CDLI file"""

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 1140 class CDLIFile(versionedFile,CatalogAwar	Line 1439 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,
	from_tmp=False,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']
except:	except:
Line 1162 class CDLIFile(versionedFile,CatalogAwar	Line 1468 class CDLIFile(versionedFile,CatalogAwar




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

if positionVersionNum=='front':	if positionVersionNum=='front':
Line 1175 class CDLIFile(versionedFile,CatalogAwar	Line 1480 class CDLIFile(versionedFile,CatalogAwar
id=tmp[0]+"_V%i"%self.getVersion()	id=tmp[0]+"_V%i"%self.getVersion()


manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type)	manage_addCDLIFileObject(self,id,vC,author,file,id,precondition, content_type,from_tmp=from_tmp)
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()))
	objs=getattr(self,id).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 1187 class CDLIFile(versionedFile,CatalogAwar	Line 1498 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 1201 def manage_addCDLIFileForm(self):	Line 1515 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)
	getattr(self,id).reindex_object()

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



	def checkFile(filename,data,folder):
	"""check the files"""
	# first check the file name
	fn=filename.split(".") # no extension

	if not fn[0][0]=="P":
	return False,"P missing in the filename"
	elif len(fn[0])!=7:
	return False,"P number has not the right length 6"
	else:
	fn=os.path.join(folder,filename)
	stin,out=os.popen4("/usr/bin/atfcheck.plx %s"%fn)
	value=out.read()
	ret= out.close()

	if value:

def splitatf(fh,dir=None):	return False,"atf checker error: %s"%value
	else:
	return True,""

	def splitatf(fh,dir=None,ext=None):
"""split it"""	"""split it"""
ret=None	ret=None
nf=None	nf=None
for line in fh.readlines():	i=0

	for lineTmp in fh.readlines():
	for line in lineTmp.split("\r"):
	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: #old convention
ret=line.replace('#atf basket ','')	ret=line.replace('#atf basket ','')
ret=ret.split('_')[0]	ret=ret.split('_')[0]
	elif line.find("#basket:")>=0: #new convention
	ret=line.replace('#basket: ','')
	ret=ret.split('_')[0]

else:	else:
if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile	if (len(line.lstrip())>0) and (line.lstrip()[0]=="&"): #newfile
if nf:	if nf:
Line 1236 def splitatf(fh,dir=None):	Line 1591 def splitatf(fh,dir=None):
return ret,len(os.listdir(dir))	return ret,len(os.listdir(dir))


class CDLIFileFolder(versionedFileFolder):	class CDLIFileFolder(extVersionedFileFolder):
"""CDLI File Folder"""	"""CDLI File Folder"""

security=ClassSecurityInfo()	security=ClassSecurityInfo()
Line 1244 class CDLIFileFolder(versionedFileFolder	Line 1599 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
	#downloadCounter=0 # counts how many download for all files currently run, be mehr als 5 wird verweigert.
	tmpStore2={}
def setTemp(self,name,value):	def setTemp(self,name,value):
"""set tmp"""	"""set tmp"""

Line 1285 class CDLIFileFolder(versionedFileFolder	Line 1642 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
thread=uploadATFThread()
self._v_uploadATF=thread
#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:]
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')
#_v_xmltrans.run()

else:
#recover thread, if lost
if not hasattr(self,'_v_uploadATF'):
for thread in threading.enumerate():
if threadName == thread.getName():
self._v_uploadATF=thread

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


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

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:	#self.REQUEST.SESSION['fileIds']=list#store fieldIds in session for further usage
#recover thread, if lost	#self.REQUEST.SESSION['searchList']=self.REQUEST.SESSION['fileIds']
if not hasattr(self,'_v_uploadATF'):
for thread in threading.enumerate():
if threadName == thread.getName():
self._v_uploadATF=thread

if hasattr(self,'_v_uploadATF') and (self._v_uploadATF is not None) and (not self._v_uploadATF.end) :

wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])	pt=getattr(self,'filelistVersioned.html')
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')
else:

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

	return pt(search=list,author=author)



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 1438 class CDLIFileFolder(versionedFileFolder	Line 1698 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))



security.declareProtected('Manage','createAllFilesAsSingleFile')	security.declareProtected('Manage','createAllFilesAsSingleFile')
def createAllFilesAsSingleFile(self,RESPONSE=None):	def createAllFilesAsSingleFile(self,RESPONSE=None):
"""download all files"""	"""download all files"""
Line 1461 class CDLIFileFolder(versionedFileFolder	Line 1731 class CDLIFileFolder(versionedFileFolder

catalog=getattr(self,self.default_catalog)	catalog=getattr(self,self.default_catalog)
#tf,tfilename=mkstemp()	#tf,tfilename=mkstemp()
	if not hasattr(self.temp_folder,'downloadCounter'):
	self.temp_folder.downloadCounter=0

	if getattr(self.temp_folder,'downloadCounter',0) > 5:
	return """I am sorry, currently the server has to many requests for downloads, please come back later!"""

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

list=[(x.getId,x) for x in catalog()]	list=[(x.getId,x) for x in catalog()]
list.sort(sortF)	list.sort(sortF)



RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")	RESPONSE.setHeader("Content-Disposition","""attachement; filename=%s"""%"all.atf")
RESPONSE.setHeader("Content-Type","application/octet-stream")	RESPONSE.setHeader("Content-Type","application/octet-stream")
	tmp=""
for l in list:	for l in list:
obj=l[1].getObject()	obj=l[1].getObject()

Line 1476 class CDLIFileFolder(versionedFileFolder	Line 1756 class CDLIFileFolder(versionedFileFolder

#os.write(tf,obj.getLastVersion().data)	#os.write(tf,obj.getLastVersion().data)
if RESPONSE:	if RESPONSE:
RESPONSE.write(obj.getLastVersion().data[0:])	RESPONSE.write(obj.getLastVersion().getData()[0:])
	self.temp_folder.downloadCounter-=1
	self._p_changed=1
	get_transaction().commit()
#os.close(tf)	#os.close(tf)
#RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)	#RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
return True	return True
Line 1509 class CDLIFileFolder(versionedFileFolder	Line 1792 class CDLIFileFolder(versionedFileFolder
return ret	return ret


def getFolders_OLD(self):	security.declareProtected('View','index_html')
"""get all subfolders"""
ret=[]
folders=self.ZopeFind(self,obj_metatypes=self.folderMetaType)
for folder in folders:
ret.append((folder[1],
len(self.ZopeFind(folder[1],obj_metatypes=self.folderMetaType)),
len(getattr(self,self.default_catalog)({'path':folder[0]}))
))
return ret

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 1529 class CDLIFileFolder(versionedFileFolder	Line 1802 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()

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

	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"
	downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible
	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))

	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(),author=author)

	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): %s</p>"%(repr(thread),thread.getName(),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]
	# 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['lockerrors']=[x[0].getId() for x in tmp['lockerrors']]
	self.REQUEST.SESSION['errors']=tmp['errors']
	self.REQUEST.SESSION['newPs']=tmp['newPs']
	self.REQUEST.SESSION['tmpdir']=tmp['dir']
	#del(self.cdli_main.tmpStore2[threadName])


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

	return pt(changed=tmp['changed'],lockerrors=tmp['lockerrors'],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'],lockerrors=tmp['lockerrors'],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/atf", files=None,ext=None):
	"""import files"""
	root=self.cdli_main
	count=0
if not files:	if not files:
files=os.listdir(folderName)	files=os.listdir(folderName)

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 1558 class CDLIFileFolder(versionedFileFolder	Line 2093 class CDLIFileFolder(versionedFileFolder
else:	else:
fobj2=obj2[0][1]	fobj2=obj2[0][1]

file2=file(os.path.join(folderName,f))	file2=os.path.join(folderName,f)
id=f	id=f
manage_addCDLIFile(fobj2,f,'','')	manage_addCDLIFile(fobj2,f,'','')
id=f	id=f
ob=fobj2._getOb(f)	ob=fobj2._getOb(f)
ob.title=id	ob.title=id

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

	if count > 1000:
	print "committing"
	get_transaction().commit()
	count=0
	get_transaction().commit()
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 1585 def manage_addCDLIFileFolder(self, id, t	Line 2127 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.21
changed lines
	Added in v.1.49