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.47 and 1.62

version 1.47, 2006/10/05 06:38:13	version 1.62, 2007/02/02 14:31:49
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.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
Line 7 import os.path	Line 6 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 20 from ZPublisher.HTTPRequest import HTTPR	Line 21 from ZPublisher.HTTPRequest import HTTPR
from ZPublisher.HTTPResponse import HTTPResponse	from ZPublisher.HTTPResponse import HTTPResponse
from ZPublisher.BaseRequest import RequestContainer	from ZPublisher.BaseRequest import RequestContainer
import threading	import threading
	from BTrees.OOBTree import OOBTree
	import logging
	import transaction
	import copy

	def unique(s):
	"""Return a list of the elements in s, but without duplicates.

	For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
	unique("abcabc") some permutation of ["a", "b", "c"], and
	unique(([1, 2], [2, 3], [1, 2])) some permutation of
	[[2, 3], [1, 2]].

	For best speed, all sequence elements should be hashable. Then
	unique() will usually work in linear time.

	If not possible, the sequence elements should enjoy a total
	ordering, and if list(s).sort() doesn't raise TypeError it's
	assumed that they do enjoy a total ordering. Then unique() will
	usually work in O(N*log2(N)) time.

	If that's not possible either, the sequence elements must support
	equality-testing. Then unique() will usually work in quadratic
	time.
	(from the python cookbook)
	"""

	n = len(s)
	if n == 0:
	return []

	# Try using a dict first, as that's the fastest and will usually
	# work. If it doesn't work, it will usually fail quickly, so it
	# usually doesn't cost much to try it. It requires that all the
	# sequence elements be hashable, and support equality comparison.
	u = {}
	try:
	for x in s:
	u[x] = 1
	except TypeError:
	del u # move on to the next method
	else:
	return u.keys()

	# We can't hash all the elements. Second fastest is to sort,
	# which brings the equal elements together; then duplicates are
	# easy to weed out in a single pass.
	# NOTE: Python's list.sort() was designed to be efficient in the
	# presence of many duplicate elements. This isn't true of all
	# sort functions in all languages or libraries, so this approach
	# is more effective in Python than it may be elsewhere.
	try:
	t = list(s)
	t.sort()
	except TypeError:
	del t # move on to the next method
	else:
	assert n > 0
	last = t[0]
	lasti = i = 1
	while i < n:
	if t[i] != last:
	t[lasti] = last = t[i]
	lasti += 1
	i += 1
	return t[:lasti]

	# Brute force is all that's left.
	u = []
	for x in s:
	if x not in u:
	u.append(x)
	return u


class BasketContent(SimpleItem):	class BasketContent(SimpleItem):
Line 63 class uploadATFfinallyThread(Thread):	Line 137 class uploadATFfinallyThread(Thread):
self.username=username	self.username=username
self.serverport=serverport	self.serverport=serverport


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

def __del__(self):	def __del__(self):
Line 120 class uploadATFfinallyThread(Thread):	Line 196 class uploadATFfinallyThread(Thread):

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

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

#do first the changed files	#do first the changed files
	i=0
for fn in uploadFns:	for fn in uploadFns:
	i+=1
founds=ctx2.CDLICatalog.search({'title':fn})	founds=ctx2.CDLICatalog.search({'title':fn})
if len(founds)>0:	if len(founds)>0:
SESSION['author']=str(username)	SESSION['author']=str(username)
self.result+="<p>Changing : %s"%fn	self.result+="<p>Changing : %s"%fn
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)
	if i==200:
	i=0
	transaction.get().commit()
	logging.info("changing: do commit")
	transaction.get().commit()
	logging.info("changing: last commit")

#now add the new files	#now add the new files
newPs=SESSION['newPs']	newPs=SESSION['newPs']
Line 190 class uploadATFfinallyThread(Thread):	Line 273 class uploadATFfinallyThread(Thread):

return True	return True

	class tmpStore(SimpleItem):
	"""simple item"""
	meta_type="cdli_upload"

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

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

Line 202 class uploadATFThread(Thread):	Line 293 class uploadATFThread(Thread):
Thread.__init__(self)	Thread.__init__(self)


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

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

def run(self):	def run(self):
	idTmp=self.idTmp
self.result=""	self.result=""
#find context within ZODB	#find context within ZODB
from Zope import DB	from Zope import DB
Line 235 class uploadATFThread(Thread):	Line 327 class uploadATFThread(Thread):
root = conn.root()	root = conn.root()
app = root['Application']	app = root['Application']
ctx = self.getContext(app,serverport=self.serverport)	ctx = self.getContext(app,serverport=self.serverport)
self.uploadATFThread(ctx,self.upload,self.basketId)	logging.info("run intern")
	ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
	logging.info("call thread intern")
	self.uploadATFThread(ctx,self.upload,idTmp,self.basketId)

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

get_transaction().commit()

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

conn.close()	conn.close()

Line 251 class uploadATFThread(Thread):	Line 344 class uploadATFThread(Thread):
"""method for accessing result"""	"""method for accessing result"""
return self.result	return self.result

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

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

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

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

Line 338 class uploadATFThread(Thread):	Line 434 class uploadATFThread(Thread):
#ready, set the returnValues	#ready, set the returnValues
self.result+="<h3>Done</h3></body></html>"	self.result+="<h3>Done</h3></body></html>"

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

	stObj.returnValue['newPs']=newPs
	stObj.returnValue['tmpdir']=dir
	stObj.returnValue['basketLen']=basketLen
	stObj.returnValue['numberOfFiles']=numberOfFiles
	stObj.returnValue['basketNameFromId']=basketNameFromId
	stObj.returnValue['basketNameFromFile']=basketNameFromFile
	stObj.returnValue['basketId']=basketId
	stObj.returnValue['dir']=dir
	#stObj.returnValue['changed']=copy.copy(changed)
	stObj.returnValue['changed']=[(x[0].getId(),x[1][0]) for x in changed]
	#stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors]
	print lockerrors
	stObj.returnValue['lockerrors']=[x for x in lockerrors]
	self.returnValue=True
#ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)	#ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)


Line 517 class BasketObject_old(Folder):	Line 618 class BasketObject_old(Folder):
"""unlock all files of the testuser for debuggin"""	"""unlock all files of the testuser for debuggin"""
for object in self.contents:	for object in self.contents:

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

def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):	def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
Line 525 class BasketObject_old(Folder):	Line 626 class BasketObject_old(Folder):

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

Line 557 class BasketObject_old(Folder):	Line 658 class BasketObject_old(Folder):

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

	transaction.get().commit()

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

Line 576 class BasketObject_old(Folder):	Line 677 class BasketObject_old(Folder):
self.REQUEST.RESPONSE.write(ret)	self.REQUEST.RESPONSE.write(ret)
self.temp_folder.downloadCounter-=1	self.temp_folder.downloadCounter-=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()



def manage_addBasket_oldObjectForm(self):	def manage_addBasket_oldObjectForm(self):
Line 690 class CDLIBasketContainer(OrderedFolder)	Line 792 class CDLIBasketContainer(OrderedFolder)
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 763 class CDLIBasketContainer(OrderedFolder)	Line 877 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 969 class CDLIBasket(Folder,CatalogAware):	Line 1087 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 987 class CDLIBasket(Folder,CatalogAware):	Line 1107 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):	def changeBasket(self,ids,submit,RESPONSE=None,REQUEST=None):
"""change a basket"""	"""change a basket"""
if submit=="update":	if submit=="update":
Line 1088 class CDLIBasketVersion(Implicit,Persist	Line 1221 class CDLIBasketVersion(Implicit,Persist

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

if lock:	if lock:

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

#check if a locked object exist in the basket.	#check if a locked object exist in the basket.
Line 1118 class CDLIBasketVersion(Implicit,Persist	Line 1251 class CDLIBasketVersion(Implicit,Persist

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

return pt()	return pt()

Line 1132 class CDLIBasketVersion(Implicit,Persist	Line 1265 class CDLIBasketVersion(Implicit,Persist

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']):
if current=="no": #version as they are in the basket	if current=="no": #version as they are in the basket
ret+=str(object[0].data)+"\n"	ret+=str(object[0].getData())+"\n"
elif current=="yes":	elif current=="yes":
#search current object	#search current object
founds=self.CDLICatalog.search({'title':object[0].getId()})	founds=self.CDLICatalog.search({'title':object[0].getId()})
if len(founds)>0:	if len(founds)>0:
ret+=str(founds[0].getObject().getLastVersion().data)+"\n"	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']
Line 1148 class CDLIBasketVersion(Implicit,Persist	Line 1281 class CDLIBasketVersion(Implicit,Persist

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

self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)	self.REQUEST.RESPONSE.setHeader("Content-Disposition","""attachement; filename="%s.atf" """%basket_name)
self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")	self.REQUEST.RESPONSE.setHeader("Content-Type","application/octet-stream")
Line 1275 class CDLIFileObject(CatalogAware,extVer	Line 1408 class CDLIFileObject(CatalogAware,extVer

security.declarePublic('view')	security.declarePublic('view')

	def getFormattedData(self):
	"""fromat text"""
	data=self.getData()
	return re.sub("\s\#lem"," #lem",data) #remove return vor #lem

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 1284 class CDLIFileObject(CatalogAware,extVer	Line 1422 class CDLIFileObject(CatalogAware,extVer
def getPNumber(self):	def getPNumber(self):
"""get the pnumber"""	"""get the pnumber"""
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 1311 class CDLIFileObject(CatalogAware,extVer	Line 1449 class CDLIFileObject(CatalogAware,extVer
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 1335 def manage_addCDLIFileObject(self,id,vC=	Line 1473 def manage_addCDLIFileObject(self,id,vC=

# 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.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')

Line 1351 class CDLIFile(extVersionedFile,CatalogA	Line 1494 class CDLIFile(extVersionedFile,CatalogA
default_catalog='CDLICatalog'	default_catalog='CDLICatalog'

#security.declarePublic('history')	#security.declarePublic('history')
	def getLastVersionData(self):
	"""get last version data"""
	return self.getLastVersion().getData()

	def getLastVersionFormattedData(self):
	"""get last version data"""
	return self.getLastVersion().getFormattedData()

	#security.declarePublic('history')


def history(self):	def history(self):
"""history"""	"""history"""

Line 1411 class CDLIFile(extVersionedFile,CatalogA	Line 1565 class CDLIFile(extVersionedFile,CatalogA
precondition='',	precondition='',
content_type='',	content_type='',
changeName='no',newName='',	changeName='no',newName='',
come_from=None,RESPONSE=None):	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 1445 class CDLIFile(extVersionedFile,CatalogA	Line 1601 class CDLIFile(extVersionedFile,CatalogA
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:	try:
#FIXME: wozu ist das gut?	#FIXME: wozu ist das gut?
self.REQUEST.SESSION['objID_parent']=self.getId()	self.REQUEST.SESSION['objID_parent']=self.getId()
Line 1497 def checkFile(filename,data,folder):	Line 1654 def checkFile(filename,data,folder):
"""check the files"""	"""check the files"""
# first check the file name	# first check the file name
fn=filename.split(".") # no extension	fn=filename.split(".") # no extension
print "_____",fn
if not fn[0][0]=="P":	if not fn[0][0]=="P":
return False,"P missing in the filename"	return False,"P missing in the filename"
elif len(fn[0])!=7:	elif len(fn[0])!=7:
Line 1509 def checkFile(filename,data,folder):	Line 1666 def checkFile(filename,data,folder):
ret= out.close()	ret= out.close()

if value:	if value:
print "ERRR"
return False,"atf checker error: %s"%value	return False,"atf checker error: %s"%value
else:	else:
return True,""	return True,""
Line 1519 def splitatf(fh,dir=None,ext=None):	Line 1676 def splitatf(fh,dir=None,ext=None):
ret=None	ret=None
nf=None	nf=None
i=0	i=0
for line in fh.readlines():
	for lineTmp in fh.readlines():
	for line in lineTmp.split("\r"):
if ext:	if ext:
i+=1	i+=1
if (i%100)==0:	if (i%100)==0:
Line 1545 def splitatf(fh,dir=None,ext=None):	Line 1704 def splitatf(fh,dir=None,ext=None):
if dir:	if dir:
filename=os.path.join(dir,filename)	filename=os.path.join(dir,filename)
nf=file(filename,"w")	nf=file(filename,"w")
	logging.info("open %s"%filename)
if nf:	if nf:
nf.write(line)	nf.write(line.replace("\n","")+"\n")

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

Line 1693 class CDLIFileFolder(extVersionedFileFol	Line 1856 class CDLIFileFolder(extVersionedFileFol

catalog=getattr(self,self.default_catalog)	catalog=getattr(self,self.default_catalog)
#tf,tfilename=mkstemp()	#tf,tfilename=mkstemp()
print self.temp_folder.downloadCounter	if not hasattr(self.temp_folder,'downloadCounter'):
if self.temp_folder.downloadCounter > 5:	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!"""	return """I am sorry, currently the server has to many requests for downloads, please come back later!"""

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

list=[(x.getId,x) for x in catalog()]	list=[(x.getId,x) for x in catalog()]
list.sort(sortF)	list.sort(sortF)
Line 1716 class CDLIFileFolder(extVersionedFileFol	Line 1881 class CDLIFileFolder(extVersionedFileFol

#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.temp_folder.downloadCounter-=1
self._p_changed=1	self._p_changed=1
get_transaction().commit()	transaction.get().commit()
#os.close(tf)	#os.close(tf)
#RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)	#RESPONSE.redirect(self.absolute_url()+"/downloadFile?fn="%tfilename)
return True	return True
Line 1800 class CDLIRoot(Folder):	Line 1965 class CDLIRoot(Folder):

meta_type="CDLIRoot"	meta_type="CDLIRoot"
downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible	downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible

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

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

	return unique(ret)

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

	return self.lineIndex

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

	if regExp:
	return self.searchRegExpInLineIndexDocs(word)

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

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

	def cleanInLineIndex(self):
	"""delete InlineIndex"""
	for x in list(self.lineIndex.keys()):
	del(self.lineIndex[x])
	print [x for x in self.lineIndex.keys()]

	return "ok"

	def storeInLineIndex(self,key,value):
	"""store in index"""

	if (not hasattr(self,'lineIndex')) or (type(self.lineIndex) is DictType):
	self.lineIndex=OOBTree()
	li=self.lineIndex

	if li.has_key(key):

	# if li[key].has_key(value[0]) and (not (value[1] in li[key][value[0]])):
	if li[key].has_key(value[0]):
	tmp=li[key][value[0]]
	tmp.append(value[1]) # add it if now in the array
	li[key][value[0]]=tmp[0:]
	else:
	li[key][value[0]]=[value[1]] # new array for lines

	else:

	li[key]=OOBTree()# new btree for lines
	li[key][value[0]]=[value[1]]


	self.lineIndex=li

	transaction.get().commit()


	def showFile(self,fileId):
	"""show a file"""
	f=self.CDLICatalog({'title':fileId})
	if not f:
	return ""

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

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

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

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

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

	file=self.showFile(fileId)

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

	if num in lineList:

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

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

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

	if num in lineList:

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

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

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

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


def forceunlock(self):	def forceunlock(self):
"break all locks"	"break all locks"
Line 1820 class CDLIRoot(Folder):	Line 2159 class CDLIRoot(Folder):

return ret	return ret

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

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

	return ret

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

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

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


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

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


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

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




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


Line 1985 class CDLIRoot(Folder):	Line 2341 class CDLIRoot(Folder):

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

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

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

Line 2019 class CDLIRoot(Folder):	Line 2376 class CDLIRoot(Folder):
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','uploadATFWait.zpt')).__of__(self)
return pt(txt='/uploadATFfinally',threadName=threadName)	return pt(txt='/uploadATFfinally',threadName=threadName)
else:	else:
	self.REQUEST.SESSION['idTmp']=None
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect(self.absolute_url())	RESPONSE.redirect(self.absolute_url())

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

Line 2040 class CDLIRoot(Folder):	Line 2397 class CDLIRoot(Folder):
if not obj:	if not obj:
manage_addCDLIFileFolder(root,folder,folder)	manage_addCDLIFileFolder(root,folder,folder)
fobj=getattr(root,folder)	fobj=getattr(root,folder)
#get_transaction().commit()	#transaction.get().commit()
else:	else:
fobj=obj[0][1]	fobj=obj[0][1]

Line 2053 class CDLIRoot(Folder):	Line 2410 class CDLIRoot(Folder):
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"
	transaction.get().commit()
	count=0
	transaction.get().commit()
return "ok"	return "ok"


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

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

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

Removed from v.1.47
changed lines
	Added in v.1.62