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.44 and 1.70

version 1.44, 2006/08/24 09:28:29	version 1.70, 2007/03/21 14:14:08
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 19 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
	import codecs

	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 62 class uploadATFfinallyThread(Thread):	Line 138 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 94 class uploadATFfinallyThread(Thread):	Line 171 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 119 class uploadATFfinallyThread(Thread):	Line 197 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 136 class uploadATFfinallyThread(Thread):	Line 214 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+self.result
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']
if len(newPs)>0:	if len(newPs)>0:
tmpDir=SESSION['tmpdir']	tmpDir=SESSION['tmpdir']
self.result+="<p>Adding files</p>"	logging.info("adding start")
	self.result="<p>Adding files</p>"+self.result
#TODO: make this configurable, at the moment base folder for the files has to be cdli_main	#TODO: make this configurable, at the moment base folder for the files has to be cdli_main

ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)	ctx2.importFiles(comment=comment,author=str(username) ,folderName=tmpDir, files=newPs,ext=self)
	logging.info("adding finished")


#unlock locked files?	#unlock locked files?
if unlock:	if unlock:
self.result+="<p>Unlock files</p>"	logging.info("unlocking start")
	self.result="<p>Unlock files</p>"+self.result
unlockFns=[]	unlockFns=[]
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['errors']:
unlockFns.append(x)	unlockFns.append(x)
	logging.info("unlocking have now what to unlock")

for fn in unlockFns:	for fn in unlockFns:
	#logging.info("will unlock: %s"%fn)
founds=ctx2.CDLICatalog.search({'title':fn})	founds=ctx2.CDLICatalog.search({'title':fn})
	#logging.info("found it: %s"%repr(founds))
if len(founds)>0:	if len(founds)>0:
	#logging.info("unlock: %s"%founds[0].getObject().getId())
SESSION['author']=str(username)	SESSION['author']=str(username)

founds[0].getObject().lockedBy=""	founds[0].getObject().lockedBy=""
	logging.info("unlocking done")

#if a basketname is give, add files to the basket	#if a basketname is given, add files to the basket
if not (basketname ==''):	if not (basketname ==''):
self.result+="<p>Add basket</p>"	logging.info("add to basket %s"%basketname)
	self.result="<p>Add to basket</p>"+self.result
basketId=ctx2.basketContainer.getBasketIdfromName(basketname)	basketId=ctx2.basketContainer.getBasketIdfromName(basketname)

if not basketId: # create new basket	if not basketId: # create new basket
	logging.info("create basket %s"%basketname)
	self.result="<p>Create a new basket</p>"+self.result
ob=ctx2.basketContainer.addBasket(basketname)	ob=ctx2.basketContainer.addBasket(basketname)
basketId=ob.getId()	basketId=ob.getId()
basket=getattr(ctx2.basketContainer,str(basketId))	basket=getattr(ctx2.basketContainer,str(basketId))
Line 186 class uploadATFfinallyThread(Thread):	Line 282 class uploadATFfinallyThread(Thread):
RESPONSE.redirect(self.aq_parent.absolute_url())	RESPONSE.redirect(self.aq_parent.absolute_url())


	logging.info("uploadfinally done")
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 201 class uploadATFThread(Thread):	Line 305 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 226 class uploadATFThread(Thread):	Line 331 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 234 class uploadATFThread(Thread):	Line 339 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")
	try:
	ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
	except:
	logging.error("thread upload: %s %s"%sys.exc_info()[0:2])

	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 250 class uploadATFThread(Thread):	Line 360 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 268 class uploadATFThread(Thread):	Line 381 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 282 class uploadATFThread(Thread):	Line 397 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 290 class uploadATFThread(Thread):	Line 405 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>"""

#start to check the files	#start to check the files
for fn in os.listdir(dir):	for fn in os.listdir(dir):

self.result+="<p>process:%s</p>"%fn	self.result="<p>process:%s</p>"%fn+self.result

# check if file is in the catalog	# check if file is in the catalog
#TODO: checkCatalog is not implemented yet	#TODO: checkCatalog is not implemented yet
Line 308 class uploadATFThread(Thread):	Line 423 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


	if not status: # error
	errors.append((fn,msg))

	else:
if len(founds)==0:	if len(founds)==0:
newPs.append(fn)	newPs.append(fn)

Line 317 class uploadATFThread(Thread):	Line 442 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,str(obj.lockedBy)))
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

#ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)


class Basket_old(Folder):
"""shopping basket - alte fassung """

meta_type="Basket"	stObj.returnValue['errors']=errors
_v_stack={}

def getObjUrl(self,objId):
"""getUrl"""
founds=self.CDLICatalog.search({'title':objId})
if len(founds)>0:
return founds[0].getObject().absolute_url()

else: #assume version number
splitted=objId.split("_")
founds=self.CDLICatalog.search({'title':splitted[1]})
return founds[0].getObject().absolute_url()+'/'+objId

def storeAllLink(self,results):
"""erzeuge link zum speicher aller results"""
nr=self.REQUEST['_ZopeId']

if results:
self._v_stack[nr]=[x.getObject().getId() for x in results]

return self.absolute_url()+"/storeAll?id="+nr

def storeAll(self,id):
"""store all"""
try:
results=self._v_stack[id]
except:
#TODO: write expired page
return "expired"

return self.storeInBasketForm(results)

def storeInBasketForm(self,ids):
""" store an object form"""

if type(ids) is not ListType:
ids=[ids]
self.REQUEST.SESSION['ids']=ids[0:]

self.REQUEST.SESSION['BACKLINK']=self.REQUEST['HTTP_REFERER']

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

def storeInBasket(self,username,ids=None,RESPONSE=None,REQUEST=None):
"""store it"""

if not ids:
ids=REQUEST.SESSION['ids']

self.REQUEST.SESSION['basketUser']=username

baskets=self.ZopeFind(self,obj_ids=[username])
if len(baskets)>0:
basket=baskets[0][1]
else:
manage_addBasketObject(self,username)
basket=self._getOb(username)


basket.addObjects(ids)
back=self.REQUEST.SESSION.get('BACKLINK', None)

if RESPONSE:
RESPONSE.redirect(back)



def showBasket(self,user=None,set=None,RESPONSE=None):
"""show the basket"""

if user:
self.REQUEST.SESSION['basketUser']=user

if not user and not set:
user=self.REQUEST.SESSION.get('basketUser',None)

if not user:
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','orizeBasketUser.zpt')).__of__(self)
return pt()
else:
baskets=self.ZopeFind(self,obj_ids=[user])


if len(baskets)>0:
RESPONSE.redirect(baskets[0][1].absolute_url())
return True
else:
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','emptyBasket.zpt')).__of__(self)
return pt()

	stObj.returnValue['newPs']=newPs
def manage_addBasket_oldForm(self):	stObj.returnValue['tmpdir']=dir
"""add the basket form"""	stObj.returnValue['basketLen']=basketLen
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addBasket.zpt')).__of__(self)	stObj.returnValue['numberOfFiles']=numberOfFiles
return pt()	stObj.returnValue['basketNameFromId']=basketNameFromId
	stObj.returnValue['basketNameFromFile']=basketNameFromFile
def manage_addBasket_old(self,id,title,RESPONSE=None):	stObj.returnValue['basketId']=basketId
"""add the basket"""	stObj.returnValue['dir']=dir
ob=Basket()	#stObj.returnValue['changed']=copy.copy(changed)
	stObj.returnValue['changed']=[(x[0].getId(),x[1][0]) for x in changed]
ob.id=str(id)	#stObj.returnValue['lockerrors']=[x[0].getId() for x in lockerrors]
ob.title=title	stObj.returnValue['lockerrors']=[x for x in lockerrors]
self._setObject(id, ob)	self.returnValue=True
ob=self._getOb(id)	#ctx2.cdli_main.setTemp('v_uploadATF_returnValue',True)

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


class BasketObject_old(Folder):
"""Basket Object - alte fassung"""

meta_type="basketObject"
def __init__(self):
"""init basket object"""
self.contents=[]

def numberOfItems(self):
"""return anzahl der elemente im basket"""
num=len(self.contents)

return num

def addObjects(self,ids):
"""addObjects"""

for id in ids:
founds=self.CDLICatalog.search({'title':id})
for found in founds:
if found.getObject() not in self.contents:
tm=self.contents[0:]
tm.append(found.getObject())
self.contents=tm[0:]

return True

def index_html(self):
"""view the basket"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','basketObject_index_html.zpt')).__of__(self)
return pt()

def deleteObjects(self,ids,RESPONSE=None):
"""delete objects"""
list = self.contents[0:]
for content in list:

if content.getId() in ids:
self.contents.remove(content)


if RESPONSE:
RESPONSE.redirect(self.absolute_url())


def unlockTest(self):
"""unlock all files of the testuser for debuggin"""
for object in self.contents:

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

def downloadObjectsAsOneFile(self,lock=None,procedure=None,REQUEST=None):
"""download all selected files in one file"""

ret=""
lockedObjects={}


if lock:

if str(self.REQUEST['AUTHENTICATED_USER'])=='Anonymous User':

return "please login first"

#check if a locked object exist in the basket.
lockedObjects={}
for object in self.contents:

if not object.lockedBy=="":
lockedObjects[object.title]=repr(object.lockedBy)


keys=lockedObjects.keys()


if len(keys)>0 and (not procedure):
self.REQUEST.SESSION['lockedObjects']=lockedObjects
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','lockedObjects.zpt')).__of__(self)
return pt()

elif not procedure: #keine fails gesperrt dann alle donwloaden
procedure="downloadAll"


for object in self.contents:

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

if lock and object.lockedBy=='':
object.lockedBy=self.REQUEST['AUTHENTICATED_USER']


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


def manage_addBasket_oldObjectForm(self):
"""add form"""
pass

def manage_addBasket_oldObject(self,id,title='',RESPONSE=None):
"""add"""

ob=BasketObject()

ob.id=str(id)
ob.title=title
self._setObject(id, ob)
ob=self._getOb(id)

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


class CDLIBasketContainer(OrderedFolder):	class CDLIBasketContainer(OrderedFolder):
Line 669 class CDLIBasketContainer(OrderedFolder)	Line 565 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 742 class CDLIBasketContainer(OrderedFolder)	Line 650 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 934 class CDLIBasket(Folder,CatalogAware):	Line 846 class CDLIBasket(Folder,CatalogAware):

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"""
	logging.info("add to basket (%s)"%(self.getId()))
lastVersion=self.getLastVersion()	lastVersion=self.getLastVersion()

if lastVersion is None:	if lastVersion is None:
Line 948 class CDLIBasket(Folder,CatalogAware):	Line 860 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:
Line 963 class CDLIBasket(Folder,CatalogAware):	Line 878 class CDLIBasket(Folder,CatalogAware):
user = username	user = username

ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)	ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
	logging.info("add to basket (%s) done"%(self.getId()))
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 1046 class CDLIBasketVersion(Implicit,Persist	Line 974 class CDLIBasketVersion(Implicit,Persist
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.content.getContent():	for object in self.content.getContent():

if not object[1].lockedBy=="":	if (not str(object[1].lockedBy)=="") and (not (str(object[1].lockedBy)==str(self.REQUEST['AUTHENTICATED_USER']))):
lockedObjects[object[1].title]=repr(object[1].lockedBy)	lockedObjects[object[1].title]=repr(object[1].lockedBy)


Line 1074 class CDLIBasketVersion(Implicit,Persist	Line 1022 class CDLIBasketVersion(Implicit,Persist
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.content.getContent():	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"""
Line 1188 def manage_addCDLIBasketVersion(self,use	Line 1146 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 1214 class CDLIFileObject(CatalogAware,versio	Line 1172 class CDLIFileObject(CatalogAware,versio


newversion=parent.manage_addCDLIFileObject('',comment,author)	newversion=parent.manage_addCDLIFileObject('',comment,author)
newversion.data=self.data[0:]	newversion.manage_upload(self.getData())

if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')	RESPONSE.redirect(self.aq_parent.absolute_url()+'/history')
Line 1224 class CDLIFileObject(CatalogAware,versio	Line 1182 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
	return re.sub("#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 1233 class CDLIFileObject(CatalogAware,versio	Line 1197 class CDLIFileObject(CatalogAware,versio
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 1247 class CDLIFileObject(CatalogAware,versio	Line 1211 class CDLIFileObject(CatalogAware,versio
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 1260 class CDLIFileObject(CatalogAware,versio	Line 1224 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 1281 def manage_addCDLIFileObject(self,id,vC=	Line 1245 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 1358 class CDLIFile(versionedFile,CatalogAwar	Line 1340 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 1392 class CDLIFile(versionedFile,CatalogAwar	Line 1376 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 1433 def manage_addCDLIFile(self,id,title,loc	Line 1418 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 checkUTF8(data):
	"""check utf 8"""
	try:
	data.encode('utf-8')
	return True
	except:
	return False


	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"
	elif not checkUTF8(data):
	return False,"not utf-8"
	else:
	return True,""

	# 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():
	lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..
	for line in lineTmp.split("\r"):
	#logging.log("Deal with: %s"%line)
if ext:	if ext:
i+=1	i+=1
if (i%100)==0:	if (i%100)==0:
Line 1455 def splitatf(fh,dir=None,ext=None):	Line 1476 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 1468 def splitatf(fh,dir=None,ext=None):	Line 1493 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 1485 class CDLIFileFolder(versionedFileFolder	Line 1514 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 1523 class CDLIFileFolder(versionedFileFolder	Line 1552 class CDLIFileFolder(versionedFileFolder

return ret	return ret

	def getFile(self,fn):
	"""get the content of the file fn"""
	founds=self.CDLICatalog.search({'title':fn})
	if not founds:
	return []
	else:
	obj=founds[0].getObject().getLastVersion()

	return obj.getData()[0:]

def checkCatalog(self,fn):	def checkCatalog(self,fn):
"""check if fn is in the catalog"""	"""check if fn is in the catalog"""
#TODO add checkCatalog	#TODO add checkCatalog



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 1542 class CDLIFileFolder(versionedFileFolder	Line 1581 class CDLIFileFolder(versionedFileFolder

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

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


	def getAllPNumbers(self):
	"""get a list of all files (resp their p-numbers) stored"""

	ret=[x.getId for x in self.CDLICatalog()]

	return ret

def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):	def findObjectsFromList(self,enterList=None,display=False,start=None,upload=None,list=None,basketName=None,numberOfObjects=None,RESPONSE=None):
"""findObjectsFromList (, TAB oder LINE separated)"""	"""findObjectsFromList (, TAB oder LINE separated)"""
Line 1607 class CDLIFileFolder(versionedFileFolder	Line 1652 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 1617 class CDLIFileFolder(versionedFileFolder	Line 1661 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 1632 class CDLIFileFolder(versionedFileFolder	Line 1686 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 1665 class CDLIFileFolder(versionedFileFolder	Line 1722 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 1722 class CDLIRoot(Folder):	Line 1769 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 1731 class CDLIRoot(Folder):	Line 1944 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 1740 class CDLIRoot(Folder):	Line 1961 class CDLIRoot(Folder):

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 1765 class CDLIRoot(Folder):	Line 1998 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 1799 class CDLIRoot(Folder):	Line 2032 class CDLIRoot(Folder):
"""check threads"""	"""check threads"""
ret="<html><body>"	ret="<html><body>"
for thread in threading.enumerate():	for thread in threading.enumerate():
ret+="<p>%s : %s</p>"%(repr(thread),thread.isAlive())	ret+="<p>%s (%s): %s</p>"%(repr(thread),thread.getName(),thread.isAlive())

return ret	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"""	"""upload an atf file / basket file"""
#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 1821 class CDLIRoot(Folder):	Line 2061 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 1845 class CDLIRoot(Folder):	Line 2086 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 1864 class CDLIRoot(Folder):	Line 2105 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])


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 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 1907 class CDLIRoot(Folder):	Line 2146 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 1941 class CDLIRoot(Folder):	Line 2181 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 1958 class CDLIRoot(Folder):	Line 2198 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+ext.result
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 1975 class CDLIRoot(Folder):	Line 2215 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 2006 def manage_addCDLIRoot(self, id, title='	Line 2252 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.44
changed lines
	Added in v.1.70