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.71 and 1.80

version 1.71, 2007/03/21 19:29:23	version 1.80, 2007/09/03 11:10:04
Line 26 import logging	Line 26 import logging
import transaction	import transaction
import copy	import copy
import codecs	import codecs
	import sys

	def unicodify(s):
	"""decode str (utf-8 or latin-1 representation) into unicode object"""
	if not s:
	return u""
	if isinstance(s, str):
	try:
	return s.decode('utf-8')
	except:
	return s.decode('latin-1')
	else:
	return s

	def utf8ify(s):
	"""encode unicode object or string into byte string in utf-8 representation.
	assumes string objects to be utf-8"""
	if not s:
	return ""
	if isinstance(s, str):
	return s
	else:
	return s.encode('utf-8')


	def generateXMLReturn(hash):
	"""erzeugt das xml file als returnwert fuer uploadATFRPC"""

	ret="<return>"

	ret+="<errors>"
	for error in hash['errors']:
	ret+="""<error atf="%s">%s</error>"""%error

	ret+="</errors>"

	ret+="<changes>"
	for changed in hash['changed']:
	ret+="""<change atf="%s">%s</change>"""%changed
	ret+="</changes>"

	ret+="<newPs>"
	for new in hash['newPs']:
	ret+="""<new atf="%s"/>"""%new
	ret+="</newPs>"

	ret+="</return>"
	return ret










def unique(s):	def unique(s):
"""Return a list of the elements in s, but without duplicates.	"""Return a list of the elements in s, but without duplicates.
Line 196 class uploadATFfinallyThread(Thread):	Line 253 class uploadATFfinallyThread(Thread):
self.result+="<h2>Start processing</h2>"	self.result+="<h2>Start processing</h2>"

#shall I only upload the changed files?	#shall I only upload the changed files?
	logging.info("uploadATFfinally procedure: %s"%procedure)
if procedure=="uploadchanged":	if procedure=="uploadchanged":
changed=[x[0] for x in SESSION.get('changed',[])]	changed=[x[0] for x in SESSION.get('changed',[])]
uploadFns=changed+SESSION.get('newPs',[])	uploadFns=changed+SESSION.get('newPs',[])
Line 341 class uploadATFThread(Thread):	Line 399 class uploadATFThread(Thread):
ctx = self.getContext(app,serverport=self.serverport)	ctx = self.getContext(app,serverport=self.serverport)
logging.info("run intern")	logging.info("run intern")
try:	try:
	logging.info("created: %s"%idTmp)
ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))	ctx.temp_folder._setObject(idTmp,tmpStore(idTmp))
except:	except:
logging.error("thread upload: %s %s"%sys.exc_info()[0:2])	logging.error("thread upload: %s %s"%sys.exc_info()[0:2])
Line 355 class uploadATFThread(Thread):	Line 414 class uploadATFThread(Thread):

conn.close()	conn.close()

	return getattr(ctx.temp_folder,idTmp)

def getResult(self):	def getResult(self):
"""method for accessing result"""	"""method for accessing result"""
Line 479 class CDLIBasketContainer(OrderedFolder)	Line 539 class CDLIBasketContainer(OrderedFolder)
security=ClassSecurityInfo()	security=ClassSecurityInfo()
meta_type="CDLIBasketContainer"	meta_type="CDLIBasketContainer"

	def getPNumbersOfBasket(self,basketName):
	"""get all pnumbers of a basket as a list, returns an empty list if basket not found
	@param basketName: name of the basket
	"""
	ret=[]
	basketId=self.getBasketIdfromName(basketName)
	if not basketId:
	return []

	ob=getattr(self,basketId).getContent()

	ret=[x[0].split(".")[0] for x in ob]

	return ret

	security.declareProtected('manage','getBasketAsOneFile')
	def getBasketAsOneFile(self,basketName,current="no"):
	"""returns all files of the basket combined in one file
	@param basketName: Name of the basket
	@param current: (optional) if current is set to "yes" then the most current version of
	all files are downloaded and not the versions of the files as stored in the basket
	"""
	ret=""
	basketId=self.getBasketIdfromName(basketName)
	if not basketId:
	return ""

	ob=getattr(self,basketId).getLastVersion()
	for object in ob.getContent():
	if current=="no": #version as they are in the basket
	ret+=str(object[0].getData())+"\n"
	elif current=="yes":
	#search current object
	logging.info("crrent: %s"%object[1].getId().split(".")[0])
	founds=self.CDLICatalog.search({'title':object[1].getId().split(".")[0]})
	if len(founds)>0:
	ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"
	return ret

	security.declareProtected('manage','upDateBaskets')
def upDateBaskets(self):	def upDateBaskets(self):
"""update content in to objects"""	"""update content in to objects"""

Line 506 class CDLIBasketContainer(OrderedFolder)	Line 606 class CDLIBasketContainer(OrderedFolder)
trash.manage_pasteObjects(cut)	trash.manage_pasteObjects(cut)

security.declareProtected('manage','manageBaskets')	security.declareProtected('manage','manageBaskets')
def manageBaskets(self,ids,submit,REQUEST=None,RESPONSE=None):	def manageBaskets(self,submit,ids=None,basket1="",basket2="",joinBasket="",subtractBasket="",REQUEST=None,RESPONSE=None):
"""manage baskets, delete or copy"""	"""manage baskets, delete or copy"""
if submit=="delete":	if submit=="delete":
self.deleteBaskets(ids)	self.deleteBaskets(ids)

	elif submit=="join":
	flag,msg=self.joinBasket(joinBasket, ids)
	logging.info("joining %s %s"%(flag,msg))

	elif submit=="subtract":
	logging.info("BBBb %s %s"%(basket1,basket2))
	flag,msg=self.subtractBasket(subtractBasket, basket1,basket2)
	logging.info("subtract %s %s"%(flag,msg))

if RESPONSE:	if RESPONSE:
RESPONSE.redirect(self.absolute_url())	RESPONSE.redirect(self.absolute_url())
Line 542 class CDLIBasketContainer(OrderedFolder)	Line 649 class CDLIBasketContainer(OrderedFolder)
return pt(basketId=basketId,basketName=basketName)	return pt(basketId=basketId,basketName=basketName)


security.declareProtected('View','index_html')	security.declareProtected('manage','index_html')
def index_html(self):	def index_html(self):
"""stanadard ansicht"""	"""stanadard ansicht"""

Line 635 class CDLIBasketContainer(OrderedFolder)	Line 742 class CDLIBasketContainer(OrderedFolder)

return baskets	return baskets

def joinBasket(self,newbasket,oldbaskets,delete=False):
	def subtractBasket(self,newBasket,basket1,basket2):
	"""subtract basket2 from basket1
	(i.e. newbasket will contain alle elements of basket1 which are not in basket2),
	if basket2 contains files which are not in basket1, then theses files fill be ignored

	@param newbasket: name of the new basket
	@param basket1: basket where basket2 will be subtracted from
	@param basket2: see above

	"""
	logging.info("CCCCC %s %s"%(basket1,basket2))

	try:
	newB=self.addBasket(newBasket)
	except:
	return False, "cannot create the new basket"





	bas2= getattr(self,basket2)
	bas2content=bas2.getContent()
	bas2ids=[x[0] for x in bas2content]



	bas1= getattr(self,basket1)
	bas1content=bas1.getContent()


	newBasketContent={}

	for id,version in bas1content:
	if not (id in bas2ids):
	newBasketContent[id]=version

	username=self.getActualUserName()

	logging.info("sbc %s"%newBasketContent)
	newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)

	return True, ""


	def joinBasket(self,newBasket,oldBaskets):
"""join two baskets	"""join two baskets
@param newbasket: name of the new basket	@param newbasket: name of the new basket
@param oldbaskets: list of baskets to be joined	@param oldbaskets: list of baskets to be joined
@param delete: (optional) delete the old baskets
"""	"""
	try:
	newB=self.addBasket(newBasket)
	except:
	return False, "cannot create the new basket"

	newBasketContent={}
	for ob in oldBaskets:
	x= getattr(self,ob,None)
	if x is None:
	return False, "cannot find basket: %s"%ob

	ids=x.getContent() # hole den Inhalt

	for id,version in ids:
	if newBasketContent.has_key(id): # p number gibt's schon
	newBasketContent[id]=max(newBasketContent[id],version) # speichere die groessere Versionsnumber
	else:
	newBasketContent[id]=version
	username=self.getActualUserName()

	logging.info("nbc %s"%newBasketContent)
	newB.addObjectsWithVersion(newBasketContent,username=username,catalog=self.CDLICatalog)

	return True, ""

def getNewId(self):	def getNewId(self):
"""createIds"""	"""createIds"""
Line 678 class CDLIBasketContainer(OrderedFolder)	Line 853 class CDLIBasketContainer(OrderedFolder)
"""get name of the actualuser"""	"""get name of the actualuser"""
return str(self.REQUEST['AUTHENTICATED_USER'])	return str(self.REQUEST['AUTHENTICATED_USER'])

	security.declareProtected('manage','addBasket')
def addBasket(self,newBasketName):	def addBasket(self,newBasketName):
"""add a new basket"""	"""add a new basket"""

Line 734 class CDLIBasket(Folder,CatalogAware):	Line 909 class CDLIBasket(Folder,CatalogAware):
meta_type="CDLIBasket"	meta_type="CDLIBasket"
default_catalog="CDLIBasketCatalog"	default_catalog="CDLIBasketCatalog"

	def searchInBasket(self,indexName,searchStr,regExp=False):
	"""searchInBasket"""

	lst=self.searchInLineIndexDocs(indexName,searchStr,uniq=True,regExp=regExp)
	ret={}

	lv=self.getLastVersion()


	for obj in lv.content.getContent():
	id=obj[1].getId().split(".")[0]
	if id in lst:

	ret[id]=self.showWordInFile(id,searchStr,lineList=self.getLinesFromIndex(indexName,searchStr,id,regExp=regExp),regExp=regExp,indexName=indexName)


	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','searchResultsInBasket')).__of__(self)
	return pt(result=ret,indexName=indexName,regExp=regExp,word=searchStr)




	def searchInBasket_v1(self,searchStr):
	"""search occurences of searchStr in files im basket"""
	ret=[]
	lv=self.getLastVersion()
	logging.info("searching")
	for obj in lv.content.getContent():
	txt=obj[0].getData()
	for x in txt.split("\n"):
	logging.info("search %s"%x)
	if re.match(searchStr,x):
	ret.append(x)

	return "\n".join(ret)


def getFile(self,obj):	def getFile(self,obj):
return obj[1]	return obj[1]
Line 786 class CDLIBasket(Folder,CatalogAware):	Line 997 class CDLIBasket(Folder,CatalogAware):
self.shortDescription=shortDescription	self.shortDescription=shortDescription
self.comment=comment	self.comment=comment

	def getActualUserName(self):
	"""get name of the actualuser"""

	return str(self.REQUEST['AUTHENTICATED_USER'])


def getLastVersion(self):	def getLastVersion(self):
Line 850 class CDLIBasket(Folder,CatalogAware):	Line 1065 class CDLIBasket(Folder,CatalogAware):

return obj	return obj

	def addObjectsWithVersion(self,ids,deleteOld=None,username=None,catalog=None):
	"""generate a new version of the basket with objects added,
	hier wird jedoch nicht die letzte Version jedes Files hinzugefuegt, s
	ondern ids is ein Tupel mit der Id (d.h. der p-number) und der Versionsnummer.
	"""
	logging.info("add to basket (%s)"%(self.getId()))
	lastVersion=self.getLastVersion()

	if not catalog:
	catalog=self.CDLICatalog

	if lastVersion is None:
	oldContent=[]
	else:
	oldContent=lastVersion.content.getContent()

	if deleteOld:
	oldContent=[]

	newContent=[]
	added=0

	for id,version in ids.iteritems():
	logging.info("adding %s %s"%(id,version))
	id=id.split(".")[0] # title nur die pnumber ohne atf

	try:
	founds=catalog.search({'title':id})
	except:
	founds=[]
	logging.info(" found %s "%(founds))
	for found in founds:
	if found.getObject() not in oldContent:

	#TODO: was passiert wenn, man eine Object dazuf�gt, das schon da ist aber eine neuere version
	newContent.append((found.getObject().getVersions()[version-1][1],found.getObject()))
	added+=1

	content=oldContent+newContent
	if not username:
	logging.error("XXXXXXXXXXX %s"%repr(self))
	user=self.getActualUserName()
	else:
	user = username

	ob=manage_addCDLIBasketVersion(self,user,comment="",basketContent=content)
	logging.info("add to basket (%s) done"%(self.getId()))
	return added


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()))	logging.info("add to basket (%s)"%(self.getId()))
Line 889 class CDLIBasket(Folder,CatalogAware):	Line 1154 class CDLIBasket(Folder,CatalogAware):



	def getContent(self):
	"""print content"""
	ret=[]

	lv=self.getLastVersion()
	for obj in lv.content.getContent():
	logging.info("XXXXXXXXXX %s"%repr(obj))
	ret.append((obj[1].getId(),obj[0].versionNumber))

	return ret

def getContentIds(self):	def getContentIds(self):
"""print basket content"""	"""print basket content"""
Line 976 class CDLIBasketVersion(Implicit,Persist	Line 1251 class CDLIBasketVersion(Implicit,Persist
return True	return True
return False	return False

security.declareProtected('View','downloadObjectsAsOneFile')	def downloadListOfPnumbers(self):
	"""download pnumbers of the basket as list"""

	basket_name=self.aq_parent.title

	ids=self.getContent() # get the list of objects
	logging.error(ids)
	ret="\n".join([x[1].getId().split(".")[0] for x in ids])

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

	security.declareProtected('manage','downloadObjectsAsOneFile')
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"""

Line 1048 class CDLIBasketVersion(Implicit,Persist	Line 1338 class CDLIBasketVersion(Implicit,Persist
ret+=str(object[0].getData())+"\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[1].getId().split(".")[0]})
if len(founds)>0:	if len(founds)>0:
ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"	ret+=str(founds[0].getObject().getLastVersion().getData())+"\n"

Line 1094 class CDLIBasketVersion(Implicit,Persist	Line 1384 class CDLIBasketVersion(Implicit,Persist
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.comment=comment
self._setObject('content',BasketContent(basketContent))	self._setObject('content',BasketContent(basketContent))
#self.basketContent=basketContent[0:]a	#self.basketContent=basketContent[0:]a
self.user=user	self.user=user
Line 1108 class CDLIBasketVersion(Implicit,Persist	Line 1398 class CDLIBasketVersion(Implicit,Persist
"""get Comment"""	"""get Comment"""
return self.comment	return self.comment

security.declareProtected('View','index_html')	security.declareProtected('manage','index_html')
def index_html(self):	def index_html(self):
"""view the basket"""	"""view the basket"""

Line 1163 class CDLIFileObject(CatalogAware,extVer	Line 1453 class CDLIFileObject(CatalogAware,extVer

security.declarePublic('makeThisVersionCurrent')	security.declarePublic('makeThisVersionCurrent')

	security.declareProtected('manage','index_html')
def PrincipiaSearchSource(self):	def PrincipiaSearchSource(self):
"""Return cataloguable key for ourselves."""	"""Return cataloguable key for ourselves."""
return str(self)	return str(self)
Line 1246 def manage_addCDLIFileObject(self,id,vC=	Line 1537 def manage_addCDLIFileObject(self,id,vC=

# First, we create the file without data:	# First, we create the file without data:
self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))	self._setObject(id, CDLIFileObject(id,title,'',content_type, precondition))
self._getOb(id).versionComment=str(vC)	fob = self._getOb(id)
self._getOb(id).time=time.localtime()	fob.versionComment=str(vC)
	fob.time=time.localtime()
setattr(self._getOb(id),'author',author)	setattr(fob,'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 and not from_tmp:	if file and not from_tmp:
self._getOb(id).manage_upload(file)	fob.manage_upload(file)
elif file and from_tmp:	elif file and from_tmp:
self._getOb(id).manage_upload_from_tmp(file)	fob.manage_upload_from_tmp(file)
if content_type:	if content_type:
self._getOb(id).content_type=content_type	fob.content_type=content_type

	logging.debug("reindex1: %s"%repr(self))
self.reindex_object()	self.reindex_object()
self._getOb(id).reindex_object()	logging.debug("reindex2: %s in %s"%(repr(fob), repr(fob.default_catalog)))
	fob.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(extVersionedFile,CatalogAware):	class CDLIFile(extVersionedFile,CatalogAware):
"""CDLI file"""	"""CDLI file"""

	security=ClassSecurityInfo()
meta_type="CDLI file"	meta_type="CDLI file"
default_catalog='CDLICatalog'	default_catalog='CDLICatalog'
	security.declareProtected('manage','index_html')
#security.declarePublic('history')	#security.declarePublic('history')
def getLastVersionData(self):	def getLastVersionData(self):
"""get last version data"""	"""get last version data"""
Line 1459 def splitatf(fh,dir=None,ext=None):	Line 1753 def splitatf(fh,dir=None,ext=None):
nf=None	nf=None
i=0	i=0

for lineTmp in fh.readlines():	if (type(fh) is StringType) or (type(fh) is UnicodeType):
	iter=fh.split("\n")
	else:
	iter=fh.readlines()

	for lineTmp in iter:
lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..	lineTmp=lineTmp.replace(codecs.BOM_UTF8,'') # make sure that all BOM are removed..
for line in lineTmp.split("\r"):	for line in lineTmp.split("\r"):
#logging.log("Deal with: %s"%line)	#logging.log("Deal with: %s"%line)
Line 1496 def splitatf(fh,dir=None,ext=None):	Line 1795 def splitatf(fh,dir=None,ext=None):
nf.close()	nf.close()
except:	except:
pass	pass

	if not((type(fh) is StringType) or (type(fh) is UnicodeType)):
fh.close()	fh.close()
return ret,len(os.listdir(dir))	return ret,len(os.listdir(dir))

Line 1551 class CDLIFileFolder(extVersionedFileFol	Line 1852 class CDLIFileFolder(extVersionedFileFol
"""get the content of the file fn"""	"""get the content of the file fn"""
founds=self.CDLICatalog.search({'title':fn})	founds=self.CDLICatalog.search({'title':fn})
if not founds:	if not founds:
return []	return ""
else:	else:
obj=founds[0].getObject().getLastVersion()	obj=founds[0].getObject().getLastVersion()

Line 1718 class CDLIFileFolder(extVersionedFileFol	Line 2019 class CDLIFileFolder(extVersionedFileFol
return ret	return ret


security.declareProtected('View','index_html')	security.declareProtected('manage','index_html')
def index_html(self):	def index_html(self):
"""main"""	"""main"""
ext=self.ZopeFind(self,obj_ids=["index.html"])	ext=self.ZopeFind(self,obj_ids=["index.html"])
Line 1767 class CDLIRoot(Folder):	Line 2068 class CDLIRoot(Folder):
meta_type="CDLIRoot"	meta_type="CDLIRoot"
downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible	downloadCounterBaskets=0# counts the current basket downloads if counter > 10 no downloads are possible

	def deleteFiles(self,ids):
	"""delete files (resp. move into .trash folder)"""
	# find or generete trash folder

	found=self.ZopeFind(self,obj_ids=['.trash'])

	if len(found)<1:
	manage_addCDLIFileFolder(self, '.trash',title="Trash")
	trash=self._getOb('.trash')
	else:
	logging.info(found)
	trash=found[0][1]


	for id in ids:
	founds=self.CDLICatalog.search({'title':id.split(".")[0]})
	if founds:
	logging.info(founds)
	folder=founds[0].getObject().aq_parent #get the parent folder of the object
	logging.info(folder)
	cut=folder.manage_cutObjects([founds[0].getId]) #cut it out
	trash.manage_pasteObjects(cut) #paste it in the trash


def findWordRegExp(self,indexName,searchTerm):	def findWordRegExp(self,indexName,searchTerm):
"""find all words in index which match regexp in SearchTerm	"""find all words in index which match regexp in SearchTerm
@param indexName: name of the index to be searched in	@param indexName: name of the index to be searched in
Line 1789 class CDLIRoot(Folder):	Line 2114 class CDLIRoot(Folder):
words=self.findWordRegExp(indexName,searchTerm) # suche nach allen Treffern	words=self.findWordRegExp(indexName,searchTerm) # suche nach allen Treffern
logging.info("wd:%s"%words)	logging.info("wd:%s"%words)
for word in words:	for word in words:

ret+=self.searchInLineIndexDocs(indexName,word)	ret+=self.searchInLineIndexDocs(indexName,word)

return unique(ret)
	x= unique(ret)
	logging.info("words_done")
	return x

def showInLineIndex(self):	def showInLineIndex(self):
"""get the index for debug purposes"""	"""get the index for debug purposes"""
Line 1896 class CDLIRoot(Folder):	Line 2225 class CDLIRoot(Folder):
transaction.get().commit()	transaction.get().commit()


def showFile(self,fileId):	def showFile(self,fileId,wholePage=False):
"""show a file	"""show a file
@param fileId: P-Number of the document to be displayed	@param fileId: P-Number of the document to be displayed
"""	"""
Line 1904 class CDLIRoot(Folder):	Line 2233 class CDLIRoot(Folder):
if not f:	if not f:
return ""	return ""

	if wholePage:
	logging.info("whole")
	return f[0].getObject().getLastVersion().view()
	else:
return f[0].getObject().getLastVersionFormattedData()	return f[0].getObject().getLastVersionFormattedData()


Line 1911 class CDLIRoot(Folder):	Line 2244 class CDLIRoot(Folder):
"""get lines with word fromFileId"""	"""get lines with word fromFileId"""

file=self.showFile(fileId)	file=self.showFile(fileId)
	logging.info("regEXP %s"%regExp)
ret=[]	ret=[]
if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen	if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen
wordlist=self.findWordRegExp(indexName,word)	wordlist=self.findWordRegExp(indexName,word)
Line 1921 class CDLIRoot(Folder):	Line 2254 class CDLIRoot(Folder):
for line in file.split("\n"):	for line in file.split("\n"):
found=False	found=False
for word in wordlist:	for word in wordlist:
	try: # just a hack because of possible unicode errors in line
if line.find(word)>-1:	if line.find(word)>-1:
if lineList: #liste of moeglichen Zeilennummern	if lineList: #liste of moeglichen Zeilennummern
num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile	num=line.split(".")[0] #Zeilenummer ist alles vor dem . in der Zeile
Line 1932 class CDLIRoot(Folder):	Line 2266 class CDLIRoot(Folder):
ret.append(line)	ret.append(line)

break;	break;
	except:
	pass
return ret	return ret

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

file=self.showFile(fileId)	file=self.showFile(fileId)
tagStr="""<span class="found">%s</span>"""	tagStr=u'<span class="found">%s</span>'
ret=[]	ret=[]

if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen	if regExp: # wenn regexp dann generiere alle worte aus der list die der regexp entsprechen
Line 1947 class CDLIRoot(Folder):	Line 2283 class CDLIRoot(Folder):
wordlist=[word]	wordlist=[word]

for line in file.split("\n"):	for line in file.split("\n"):
	line = unicodify(line)
found=False	found=False
for word in wordlist:	for word in wordlist:
if line.find(word)>-1: #word ist gefunden dann makiere und breche die Schleife ab	if line.find(word)>-1: #word ist gefunden dann makiere und breche die Schleife ab
Line 1964 class CDLIRoot(Folder):	Line 2301 class CDLIRoot(Folder):
if not found: #word wurde nicht gefunden keine makierung	if not found: #word wurde nicht gefunden keine makierung
ret.append(line)	ret.append(line)

return "<br>\n".join(ret)	return u'<br>\n'.join(ret)

def URLquote(self,str):	def URLquote(self,str):
"""quote url"""	"""quote url"""
Line 2056 class CDLIRoot(Folder):	Line 2393 class CDLIRoot(Folder):
return ret	return ret


	def uploadATFRPC(self,data,username):
	"""upload an atffile via xml-rpc"""
	uploader=uploadATFThread()

	#generate an random id for the upload object
	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)


	uploader.set(data,0,username,idTmp)

	stObj=uploader.run()

	processor=uploadATFfinallyThread()

	basketname=stObj.returnValue['basketNameFromFile']

	processor.set("uploadchanged",basketname=basketname,SESSION=stObj.returnValue,username=username,serverport=self.REQUEST['SERVER_PORT'])

	processor.run()


	return generateXMLReturn(stObj.returnValue)

def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):	def uploadATF(self,repeat=None,upload=None,basketId=0,RESPONSE=None):
"""upload an atf file / basket file"""	"""upload an atf file / basket file"""

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

Removed from v.1.71
changed lines
	Added in v.1.80