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.37 and 1.61

version 1.37, 2006/07/14 19:08:30	version 1.61, 2007/01/30 14:26:42
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
	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):
	"""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):
Line 41 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 73 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
	print "ended"
return True	return True

def __del__(self):	def __del__(self):
Line 98 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":
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 120 class uploadATFfinallyThread(Thread):	Line 218 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 168 class uploadATFfinallyThread(Thread):	Line 266 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 180 class uploadATFThread(Thread):	Line 286 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 205 class uploadATFThread(Thread):	Line 312 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 213 class uploadATFThread(Thread):	Line 320 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 229 class uploadATFThread(Thread):	Line 337 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 247 class uploadATFThread(Thread):	Line 358 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

Line 261 class uploadATFThread(Thread):	Line 374 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 269 class uploadATFThread(Thread):	Line 382 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 287 class uploadATFThread(Thread):	Line 400 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 296 class uploadATFThread(Thread):	Line 417 class uploadATFThread(Thread):
obj=found.getObject()	obj=found.getObject()

if (not (str(obj.lockedBy))=='') and (not (str(obj.lockedBy)==str(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>"

self.returnValue={}	stObj.returnValue={}
self.returnValue['changed']=changed
self.returnValue['errors']=errors
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['errors']=errors

	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 446 class BasketObject_old(Folder):	Line 572 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 483 class BasketObject_old(Folder):	Line 611 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 492 class BasketObject_old(Folder):	Line 620 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 518 class BasketObject_old(Folder):	Line 649 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

	transaction.get().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 533 class BasketObject_old(Folder):	Line 668 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
	transaction.get().commit()



def manage_addBasket_oldObjectForm(self):	def manage_addBasket_oldObjectForm(self):
Line 560 class CDLIBasketContainer(OrderedFolder)	Line 699 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')	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 638 class CDLIBasketContainer(OrderedFolder)	Line 785 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 693 class CDLIBasketContainer(OrderedFolder)	Line 852 class CDLIBasketContainer(OrderedFolder)
baskets.sort(sortAuthor)	baskets.sort(sortAuthor)
elif sortField=='comment':	elif sortField=='comment':
baskets.sort(sortComment)	baskets.sort(sortComment)
print "got the baskets"
return baskets	return baskets


Line 711 class CDLIBasketContainer(OrderedFolder)	Line 870 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 785 class CDLIBasket(Folder,CatalogAware):	Line 948 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 840 class CDLIBasket(Folder,CatalogAware):	Line 1004 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 860 class CDLIBasket(Folder,CatalogAware):	Line 1034 class CDLIBasket(Folder,CatalogAware):
ids=[ids]	ids=[ids]

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

#first copy the old	#first copy the old
Line 883 class CDLIBasket(Folder,CatalogAware):	Line 1057 class CDLIBasket(Folder,CatalogAware):

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

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

RESPONSE.redirect(obj.absolute_url())	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 895 class CDLIBasket(Folder,CatalogAware):	Line 1072 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 903 class CDLIBasket(Folder,CatalogAware):	Line 1080 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 921 class CDLIBasket(Folder,CatalogAware):	Line 1100 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 935 class CDLIBasket(Folder,CatalogAware):	Line 1127 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 969 def manage_addCDLIBasket(self,title,shor	Line 1161 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()	security=ClassSecurityInfo()

	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):	def containsNonActualFiles(self):
"""returns True if basket contains one or more non current files"""	"""returns True if basket contains one or more non current files"""

Line 988 class CDLIBasketVersion(SimpleItem):	Line 1193 class CDLIBasketVersion(SimpleItem):
def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None,check="yes",current="no"):	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():	if (check=="yes") and self.containsNonActualFiles():
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','downloadObjectAsOneFile_check.zpt')).__of__(self)

return pt(lock=lock)	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
	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._p_changed=1
	transaction.get().commit()
	self.temp_folder.downloadCounterBaskets-=1
	self._p_changed=1
	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.
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 1016 class CDLIBasketVersion(SimpleItem):	Line 1241 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
	transaction.get().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']):
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']

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
	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")
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 1066 class CDLIBasketVersion(SimpleItem):	Line 1301 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 1090 class CDLIBasketVersion(SimpleItem):	Line 1326 class CDLIBasketVersion(SimpleItem):
"""view the basket"""	"""view the basket"""

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

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 1128 def manage_addCDLIBasketVersion(self,use	Line 1365 def manage_addCDLIBasketVersion(self,use
else:	else:
return ob	return ob

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

meta_type="CDLI File Object"	meta_type="CDLI File Object"
Line 1164 class CDLIFileObject(CatalogAware,versio	Line 1401 class CDLIFileObject(CatalogAware,versio

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)
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 1186 class CDLIFileObject(CatalogAware,versio	Line 1442 class CDLIFileObject(CatalogAware,versio
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 1207 def manage_addCDLIFileObject(self,id,vC=	Line 1463 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')	#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 1235 class CDLIFile(versionedFile,CatalogAwar	Line 1509 class CDLIFile(versionedFile,CatalogAwar
return pt()	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):
"""check is this file is part of any basket	"""check is this file is part of any basket
Line 1272 class CDLIFile(versionedFile,CatalogAwar	Line 1558 class CDLIFile(versionedFile,CatalogAwar
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 1306 class CDLIFile(versionedFile,CatalogAwar	Line 1594 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:	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 1347 def manage_addCDLIFile(self,id,title,loc	Line 1636 def manage_addCDLIFile(self,id,title,loc


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:

	return False,"atf checker error: %s"%value
	else:
	return True,""

def splitatf(fh,dir=None,ext=None):	def splitatf(fh,dir=None,ext=None):
"""split it"""	"""split it"""
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 1369 def splitatf(fh,dir=None,ext=None):	Line 1680 def splitatf(fh,dir=None,ext=None):
i=0	i=0
ext.result+="<br>"	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 1382 def splitatf(fh,dir=None,ext=None):	Line 1697 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))


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

security=ClassSecurityInfo()	security=ClassSecurityInfo()
Line 1399 class CDLIFileFolder(versionedFileFolder	Line 1718 class CDLIFileFolder(versionedFileFolder
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	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={}	tmpStore2={}
def setTemp(self,name,value):	def setTemp(self,name,value):
"""set tmp"""	"""set tmp"""
Line 1443 class CDLIFileFolder(versionedFileFolder	Line 1762 class CDLIFileFolder(versionedFileFolder



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

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

return pt(search=list)	return pt(search=list,author=author)



Line 1521 class CDLIFileFolder(versionedFileFolder	Line 1840 class CDLIFileFolder(versionedFileFolder
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 1531 class CDLIFileFolder(versionedFileFolder	Line 1849 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
	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)



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 1546 class CDLIFileFolder(versionedFileFolder	Line 1874 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
	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 1579 class CDLIFileFolder(versionedFileFolder	Line 1910 class CDLIFileFolder(versionedFileFolder
return ret	return ret


def getFolders_OLD(self):
"""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
security.declareProtected('View','index_html')	security.declareProtected('View','index_html')
def index_html(self):	def index_html(self):
"""main"""	"""main"""
Line 1636 class CDLIRoot(Folder):	Line 1957 class CDLIRoot(Folder):
"""main folder for cdli"""	"""main folder for cdli"""

meta_type="CDLIRoot"	meta_type="CDLIRoot"
	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"""
Line 1645 class CDLIRoot(Folder):	Line 2132 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"
ret=[]	ret=[]
for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):	for f in self.ZopeFind(self,obj_metatypes="CDLI file",search_sub=1):
un=f[1].forceunlock()	un=f[1].forceunlock()
print un
if un and un !="":	if un and un !="":
ret.append((f[0],un))	ret.append((f[0],un))
print 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	return ret

def getChangesByAuthor(self,author,n=100):	def getChangesByAuthor(self,author,n=100):
Line 1679 class CDLIRoot(Folder):	Line 2186 class CDLIRoot(Folder):
tmp[id]=(x.getObject().aq_parent,nr)	tmp[id]=(x.getObject().aq_parent,nr)


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

def getLastChanges(self,n=100):	def getLastChanges(self,n=100):
"""get the last n changes"""	"""get the last n changes"""
Line 1711 class CDLIRoot(Folder):	Line 2218 class CDLIRoot(Folder):

def checkThreads(self):	def checkThreads(self):
"""check threads"""	"""check threads"""
return threading.enumerate()	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):	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 1729 class CDLIRoot(Folder):	Line 2249 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 1753 class CDLIRoot(Folder):	Line 2274 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 1772 class CDLIRoot(Folder):	Line 2293 class CDLIRoot(Folder):
# tmp[key]=self._v_uploadATF[threadName].returnValue[key][0:]	# tmp[key]=self._v_uploadATF[threadName].returnValue[key][0:]
# else:	# else:
# tmp[key]=self._v_uploadATF[threadName].returnValue[key]	# tmp[key]=self._v_uploadATF[threadName].returnValue[key]
# print repr(tmp[key]),repr(key)	# repr(tmp[key]),repr(key)
#	#
# #	# #
#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['errors']=[x.getId() for x in tmp['errors']]
self.REQUEST.SESSION['newPs']=tmp['newPs']
self.REQUEST.SESSION['tmpdir']=tmp['dir']
#del(self.cdli_main.tmpStore2[threadName])	#del(self.cdli_main.tmpStore2[threadName])
print "here the templates"

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

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

def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):	def uploadATFfinally(self,procedure='',comment="",basketname='',unlock=None,repeat=None,RESPONSE=None):
Line 1812 class CDLIRoot(Folder):	Line 2331 class CDLIRoot(Folder):
if (not hasattr(self,'_v_uploadATF')):	if (not hasattr(self,'_v_uploadATF')):
self._v_uploadATF={}	self._v_uploadATF={}

self._v_uploadATF[threadName]=thread

	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'])	idTmp=self.REQUEST.SESSION['idTmp']
	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 1848 class CDLIRoot(Folder):	Line 2369 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 1865 class CDLIRoot(Folder):	Line 2386 class CDLIRoot(Folder):
obj=self.ZopeFind(root,obj_ids=[folder])	obj=self.ZopeFind(root,obj_ids=[folder])
if ext:	if ext:

ext.result+="<p>Adding: %s </p>"%f	ext.result+="<p>adding: %s </p>"%f
if not obj:	if not obj:
manage_addCDLIFileFolder(root,folder,folder)	manage_addCDLIFileFolder(root,folder,folder)
fobj=getattr(root,folder)	fobj=getattr(root,folder)
#get_transaction().commit()	#transaction.get().commit()
else:	else:
fobj=obj[0][1]	fobj=obj[0][1]

Line 1882 class CDLIRoot(Folder):	Line 2403 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 1913 def manage_addCDLIRoot(self, id, title='	Line 2440 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.37
changed lines
	Added in v.1.61