MPIWGWeb/MPIWGRoot.py - diff

Return to MPIWGRoot.py CVS log

Up to [Repository] / MPIWGWeb

Diff for /MPIWGWeb/Attic/MPIWGRoot.py between versions 1.1.2.9 and 1.1.2.42

version 1.1.2.9, 2008/09/01 15:42:58	version 1.1.2.42, 2012/12/07 10:12:56
Line 21 from bibliography import *	Line 21 from bibliography import *
import time	import time
import xml.dom.minidom	import xml.dom.minidom
import sys	import sys
from Ft.Xml.XPath import Evaluate	import transaction
from Ft.Xml.XPath.Context import Context
from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print	#from Ft.Xml.XPath import Evaluate
from Ft.Xml import EMPTY_NAMESPACE	#from Ft.Xml.XPath.Context import Context
	#from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
	#from Ft.Xml import EMPTY_NAMESPACE
import copy	import copy
import updatePersonalWWW	import updatePersonalWWW
import MPIWGStaff	import MPIWGStaff
from MPIWGHelper import *	from MPIWGHelper import *
	from BeautifulSoup import BeautifulSoup, Comment
	from ZODB import FileStorage, DB
	from ZEO import ClientStorage

def sortWeight(x,y):	def sortWeight(x,y):
x1=int(getattr(x[1],'weight','0'))	x1=int(getattr(x[1],'weight','0'))
Line 40 def sortWeight(x,y):	Line 44 def sortWeight(x,y):
class MPIWGRoot(ZSQLExtendFolder):	class MPIWGRoot(ZSQLExtendFolder):
"""Stammordner fuer den Web-Server"""	"""Stammordner fuer den Web-Server"""

	_v_harvestCache=None
	meta_type='MPIWGRoot'

fieldLabels={'WEB_title':'WEB_Title',	fieldLabels={'WEB_title':'WEB_Title',
'xdata_01':'Responsible Scientists',	'xdata_01':'Responsible Scientists',
'xdata_02':'Department',	'xdata_02':'Department',
Line 58 class MPIWGRoot(ZSQLExtendFolder):	Line 65 class MPIWGRoot(ZSQLExtendFolder):
'WEB_project_description':'WEB_project_description',	'WEB_project_description':'WEB_project_description',
'WEB_related_pub':'WEB_related_pub'}	'WEB_related_pub':'WEB_related_pub'}

	# (is this used?)
folders=['MPIWGProject','Folder','ECHO_Navigation']	folders=['MPIWGProject','Folder','ECHO_Navigation']
meta_type='MPIWGRoot'	# language of this instance
	lang = 'en'
	# types of objects that show up in navigation
	nav_meta_types = ['MPIWGTemplate','MPIWGLink','MPIWGFolder']

	manage_options = Folder.manage_options+(
	{'label':'Update personal homepages','action':'updatePersonalwww_html'},
	{'label':'Reindex catalogs','action':'reindexCatalogs'},
	{'label':'Main config','action':'changeMPIWGRootForm'},
	{'label':'add e-mails','action':'showNewDBEntries'},
	#{'label':'update the institutsbibliography','action':'updateInstitutsbiliography'},
	#{'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
	#{'label':'Store Historical Persons','action':'storeHistoricalPersons'},
	)


	def getHarvestCachePort(self):
	return getattr(self,"harvestPort",29999)

	def getHarvestCacheServer(self):
	return getattr(self,"harvestServer","localhost")


	def getHarvestCache(self):
	logging.debug("CACHE:"+repr(self._v_harvestCache))
	if self._v_harvestCache==None:
	#storage = FileStorage.FileStorage('/tmp/'+self.getId()+'test-filestorage.fs')
	addr = self.getHarvestCacheServer(), self.getHarvestCachePort()
	storage = ClientStorage.ClientStorage(addr)
	db = DB(storage)
	self._v_harvestDV=db
	self._v_harvestDV=db
	conn = db.open()
	dbroot = conn.root()
	if not dbroot.has_key('templates'):
	from BTrees.OOBTree import OOBTree
	dbroot['templates'] = OOBTree()

	self._v_harvestCache = dbroot['templates']
	logging.debug("CACHE2:"+repr(self._v_harvestCache))
	return self._v_harvestCache



	def __del__(self):
	if self._v_harvestCache!=None:
	self._v_harvestDV.close();

	def getGetNeighbourhood(self,obj, wordStr, length=100,tagging=True):
	"""finde umgebung um die worte in wordStr, zurueckgegeben wird eine Array mit den Umgebungen von Fundstellen der Worte
	alle Tags werden entfernt, die Fundstellen werden mit <span class="found">XX</span> getaggt, die Umgebungen werden
	case insensitive gesucht
	@param wordStr: string mit Worten getrennt durch Leerzeichen, Phrasen sind mit " gekennzeichnet
	"eine phrase", "*" bezeichnet wildcards und wird ignoriert"
	@param length: optional, default wert 100, 2*length ist die groesse der Umgebung
	@param tagging: optional default wert true, kein span tag wird erzweugt falls tag=false
	"""

	ret=[] # nimmt das Array auf, dass spaeter zurueckgegeben wird
	ranges=[] #Array mit tupeln x,y wobei x die Position des Anfang und y des Endes der i-ten Umgebung angiebt

	wordStr=wordStr.lstrip().rstrip()

	def isInRanges(nr,length):
	"""test ob eine gegeben Position nr schon irgendwo in einer Umgebung ist, gibt den Index des ersten Wertes aus ranges zurueck,
	-1, wenn kein Treffer

	@param nr: Position die geprueft werden soll
	@param length: Laenge des Wortes das geprueft werden soll
	"""
	for x in ranges:
	if (x[0]<=nr) and (nr < (x[1]-length)):
	return ranges.index(x)
	return -1

	# deal with phrases, in Phrasen werden die Leerzeichen durch "_" ersetzt.
	def rep_empty(str):
	x= re.sub(" ","_",str.group(0))
	return re.sub("\"","",x)

	wordStr=re.sub("\".*?\"", rep_empty,wordStr)#ersetze leerzeichen in " " durch "_" und loesche "

	#deal with wildcards, for our purposes it is enough to delete the wildcard
	wordStr=wordStr.replace("*","")

	words=wordStr.split(" ")
	#if not words is ListType:
	# words=[words]


	txtCache = self.en.getHarvestCache();
	txt= txtCache.get(obj.absolute_url(),None)

	if txt==None:

	logging.debug("NO CACHE for: "+obj.absolute_url())
	txt=obj.harvest_page(mode="slim")


	if not txt:
	return ret

	soup = BeautifulSoup(txt)

	comments = soup.findAll(text=lambda text:isinstance(text, Comment))
	[comment.extract() for comment in comments]

	txt = ''.join(soup.findAll(text=True))


	#txt=re.sub("<.*?>", "", txt) # loesche alle Tags
	for word in words:
	word=re.sub("_"," ",word) # ersetze zurueck "_" durch " "
	pos=0

	n=txt.lower().count(word.lower()) # wie oft tritt das Wort auf

	for i in range(n):
	pos=txt.lower().find(word.lower(),pos)

	if pos > 0:
	x=max(0,pos-length)
	y=min(len(txt),pos+length)


	#is word already in one of the results
	nr=isInRanges(pos,len(word))
	if nr >=0:# word ist in einer schon gefunden Umgebung, dann vergroessere diese
	x=min(ranges[nr][0],x)
	y=max(ranges[nr][1],y)

	str=txt[x:y]
	if x!=0: #add dots if in the middle of text
	str="..."+str

	if y!=len(txt): #add dots if in the middle of text
	str=str+"..."



	if nr >=0: # word ist in einer schon gefunden Umgebung
	ranges[nr]=(x,y) # neue Position der Umgebung

	ret[nr]=str # neue Umgebung
	else: # andernfalls neue Umgebung hinzufuegen
	ranges.append((x,y))

	ret.append(str)

	pos=pos+len(word)
	else:
	break;

	# now highlight everything
	if tagging:
	for x in range(len(ret)):
	for word in words:
	repl=re.compile(word,re.IGNORECASE)
	ret[x]=repl.sub(""" <span class="found">%s</span>"""%word.upper(),ret[x])

	return ret
def copyAllImagesToMargin(self):	def copyAllImagesToMargin(self):
"""tranformiere alle Bilder in die Margins"""	"""tranformiere alle Bilder in die Margins"""
projects=self.getTree()	projects=self.getTree()
Line 78 class MPIWGRoot(ZSQLExtendFolder):	Line 245 class MPIWGRoot(ZSQLExtendFolder):
projects=self.getTree()	projects=self.getTree()
ret=""	ret=""
for project in projects:	for project in projects:

proj=project[3]	proj=project[3]
persons=proj.identifyNames(proj.getContent('xdata_01'))	persons=proj.identifyNames(proj.getContent('xdata_01'))
if not hasattr(proj,'responsibleScientistsList'):	if not hasattr(proj,'responsibleScientistsList'):
Line 135 class MPIWGRoot(ZSQLExtendFolder):	Line 303 class MPIWGRoot(ZSQLExtendFolder):
else:	else:
return array[idx]	return array[idx]

	def getLang(self):
	"""returns the default language"""
	return self.lang

def browserCheck(self):	def browserCheck(self):
"""check the browsers request to find out the browser type"""	"""check the browsers request to find out the browser type"""
Line 225 class MPIWGRoot(ZSQLExtendFolder):	Line 396 class MPIWGRoot(ZSQLExtendFolder):
return base	return base

def isNewCapital(self,text=None,reset=None):	def isNewCapital(self,text=None,reset=None):

	if text:
	text=text.upper()
if reset:	if reset:
self.REQUEST['capital']="A"	self.REQUEST['capital']="A"
return True	return True
Line 237 class MPIWGRoot(ZSQLExtendFolder):	Line 411 class MPIWGRoot(ZSQLExtendFolder):

def subNavStatic(self,obj):	def subNavStatic(self,obj):
"""subnav" von self"""	"""subnav" von self"""
def sortWeight(x,y):
x1=int(getattr(x[1],'weight','0'))
y1=int(getattr(y[1],'weight','0'))
return cmp(x1,y1)

subs=self.ZopeFind(obj,obj_metatypes=['MPIWGTemplate','MPIWGLink'])	subs=self.ZopeFind(obj,obj_metatypes=['MPIWGTemplate','MPIWGLink'])
subret=[]	subret=[]

Line 252 class MPIWGRoot(ZSQLExtendFolder):	Line 421 class MPIWGRoot(ZSQLExtendFolder):
return subret	return subret

def subNav(self,obj):	def subNav(self,obj):
"""return subnav elemente"""	"""return sub-navigation elements i.e. below sections"""
def sortWeight(x,y):	# get section -> parent should be MPIWGRoot
x1=int(getattr(x[1],'weight','0'))	p = obj
y1=int(getattr(y[1],'weight','0'))	sec = None
return cmp(x1,y1)	# descend parents to the root (and remember the last id)
#if obj.meta_type in ['MPIWGTemplate','MPIWGLink']:	while p is not None and p.meta_type != 'MPIWGRoot':
# id=obj.aq_parent.getId()	sec = p
#else:	p = p.aq_parent

#id=obj.getId()	subsecs = sec.objectItems(self.nav_meta_types)
	subsecs = [s for s in subsecs if s[1].title != ""]
	subsecs.sort(sortWeight)
#suche die zweite ebene	return subsecs

if not obj.aq_parent.getId() in ['de','en']:	def isType(self,object,meta_type):
obj=obj.aq_parent	"""teste ob ein object vom meta_type ist."""
	return (object.meta_type==meta_type)
while not self.ZopeFind(self,obj_ids=[obj.getId()]):
obj=obj.aq_parent


if hasattr(self,obj.getId()):

subs=self.ZopeFind(getattr(self,obj.getId()),obj_metatypes=['MPIWGTemplate','MPIWGLink'])
subret=[]

for x in subs:
if not(x[1].title==""):
subret.append(x)
subret.sort(sortWeight)
return subret
else:
return None

def isActive(self,name):	def isActive(self,name):
"""teste ob subnavigation aktiv"""	"""teste ob subnavigation aktiv"""
Line 299 class MPIWGRoot(ZSQLExtendFolder):	Line 452 class MPIWGRoot(ZSQLExtendFolder):
secs = self.objectItems(['MPIWGFolder'])	secs = self.objectItems(['MPIWGFolder'])
secs.sort(sortWeight)	secs.sort(sortWeight)
#logging.debug("root: %s secs: %s"%(repr(self.absolute_url()), repr(secs)))	#logging.debug("root: %s secs: %s"%(repr(self.absolute_url()), repr(secs)))
return secs	# return pure list of objects
	return [s[1] for s in secs]

def getSectionStyle(self, name, style=""):	def getSectionStyle(self, name, style=""):
"""returns a string with the given style + '-sel' if the current section == name"""	"""returns a string with the given style + '-sel' if the current section == name"""
Line 308 class MPIWGRoot(ZSQLExtendFolder):	Line 462 class MPIWGRoot(ZSQLExtendFolder):
else:	else:
return style	return style

	def getFeatures(self, num=None):
	"""returns a list of the last num Features"""
	dir = getattr(self, 'features')
	features = dir.objectItems(['MPIWGFeature'])
	features.sort(sortWeight)
	if num is not None:
	# take only the last num elements
	features = features[-num:]
	# return pure list of objects
	return [f[1] for f in features]


	def getMPIWGRoot(self):
	"""returns the MPIWG root"""
	return self

def MPIWGrootURL(self):	def MPIWGrootURL(self):
"""returns the URL to the root"""	"""returns the URL to the root"""
return self.absolute_url()	return self.absolute_url()
Line 339 class MPIWGRoot(ZSQLExtendFolder):	Line 509 class MPIWGRoot(ZSQLExtendFolder):

def isActiveMember(self,key):	def isActiveMember(self,key):
"""tested ob Mitarbeiter key ist aktiv"""	"""tested ob Mitarbeiter key ist aktiv"""
	key=utf8ify(key)
ret=self.getat(self.ZSQLInlineSearch(_table='personal_www',	ret=self.getat(self.ZSQLInlineSearch(_table='personal_www',
_op_key='eq',key=key,	_op_key='eq',key=key,
_op_publish_the_data='eq',	_op_publish_the_data='eq',
Line 494 class MPIWGRoot(ZSQLExtendFolder):	Line 665 class MPIWGRoot(ZSQLExtendFolder):
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)
return pt()	return pt()

def changeMPIWGRoot(self,title,disciplineList,themesList,connection_id,RESPONSE=None):	def changeMPIWGRoot(self,title,connection_id,coneServiceURL,harvestPort,harvestServer,lang=None,autocommit=None,RESPONSE=None):
"""change"""	"""change"""
self.title=title	self.title=title
self.connection_id=connection_id	self.connection_id=connection_id
self.disciplineList=disciplineList	#self.disciplineList=disciplineList
self.themesList=themesList	#self.themesList=themesList
	self.coneServiceURL=coneServiceURL
	self.harvestServer=harvestServer
	try:
	self.harvestPort=int(harvestPort)
	except:
	logging.error("couldn't change port!: no number:"+harvestPort)

	if lang is not None:
	self.lang = lang

	self.autocommit = (autocommit == "on")
if RESPONSE is not None:	if RESPONSE is not None:
RESPONSE.redirect('manage_main')	RESPONSE.redirect('manage_main')

Line 537 class MPIWGRoot(ZSQLExtendFolder):	Line 718 class MPIWGRoot(ZSQLExtendFolder):
else:	else:
ret.append(project)	ret.append(project)

logging.debug("getContexts: childs=%s parents=%s depth=%s => %s"%(childs,parents,depth,repr(ret)))	#logging.debug("getContexts: childs=%s parents=%s depth=%s => %s"%(childs,parents,depth,repr(ret)))

return ret	return ret


	def getAllProjectsAndTagsAsCSV(self,archived=1,RESPONSE=None):
	"""alle projekte auch die nicht getaggten"""
	retList=[]
	headers=['projectId','sortingNumber','projectName','scholars','startedAt','completedAt','lastChangeThesaurusAt','lastChangeProjectAt','projectCreatedAt','persons','places','objects']
	headers.extend(list(self.thesaurus.tags.keys()))
	retList.append("\t".join(headers))
	if not hasattr(self,'thesaurus'):
	return "NON thesaurus (there have to be a MPIWGthesaurus object, with object ID thesaurus)"

	projectTags = self.thesaurus.getProjectsAndTags()
	for project in self.getProjectFields('WEB_title_or_short'):
	proj = project[0]
	p_name = project[1]
	retProj=[]
	#if (not proj.isArchivedProject() and archived==1) or (proj.isArchivedProject() and archived==2):
	retProj.append(self.utf8ify(proj.getId()))
	retProj.append(self.utf8ify(proj.getContent('xdata_05')))
	retProj.append(self.utf8ify(p_name))
	retProj.append(self.utf8ify(proj.getContent('xdata_01')))
	retProj.append(self.utf8ify(proj.getStartedAt()))
	retProj.append(self.utf8ify(proj.getCompletedAt()))
	changeDate=self.thesaurus.lastChangeInThesaurus.get(proj.getId(),'')
	n = re.sub("[:\- ]","",str(changeDate))
	retProj.append(n)
	retProj.append(self.utf8ify(getattr(proj,'creationTime','20050101000000')))
	retProj.append("")#TODO: project created at
	retProj.append(";".join([person[1] for person in self.thesaurus.getPersonsFromProject(proj.getId())]))
	retProj.append(";".join([person[1] for person in self.thesaurus.getHistoricalPlacesFromProject(proj.getId())]))
	retProj.append(";".join([person[1] for person in self.thesaurus.getObjectsFromProject(proj.getId())]))
	retProj+=self.thesaurus.getTags(proj.getId(),projectTags)
	retList.append("\t".join(retProj))

	if RESPONSE:

	RESPONSE.setHeader('Content-Disposition','attachment; filename="ProjectsAndTags.tsv"')
	RESPONSE.setHeader('Content-Type', "application/octet-stream")

	return "\n".join(retList);




def getProjectFields(self,fieldName,date=None,folder=None,sort=None):	def getProjectFields(self,fieldName,date=None,folder=None,sort=None):
"""getListofFieldNames"""	"""getListofFieldNames"""
ret=[]	ret=[]
Line 585 class MPIWGRoot(ZSQLExtendFolder):	Line 809 class MPIWGRoot(ZSQLExtendFolder):
return projects	return projects


manage_options = Folder.manage_options+(
{'label':'Update personal homepages','action':'updatePersonalwww_html'},
{'label':'Reindex catalogs','action':'reindexCatalogs'},
{'label':'Main config','action':'changeMPIWGRootForm'},
{'label':'add e-mails','action':'showNewDBEntries'},
{'label':'update the institutsbibliography','action':'updateInstitutsbiliography'},
#{'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
#{'label':'Store Historical Persons','action':'storeHistoricalPersons'},
)


def updatePublicationDB(self,personId=None):	def updatePublicationDB(self,personId=None):
"""updates the publication db, i.e. copy year and type into the main table"""	"""updates the publication db, i.e. copy year and type into the main table"""

Line 681 class MPIWGRoot(ZSQLExtendFolder):	Line 894 class MPIWGRoot(ZSQLExtendFolder):


result,msg=MPIWGStaff.createNewDBEntry(self,data['publish_the_data'],data['key'],data['last_name'],	result,msg=MPIWGStaff.createNewDBEntry(self,data['publish_the_data'],data['key'],data['last_name'],
data['first_name'],data['title'],data['status'],"",	data['first_name'],data['titles_new'],data['status'],"",
"",data['date_from'],data['date_to'],	"",data['date_from'],data['date_to'],
data['department'],data['home_inst'],data['funded_by'],	data['department'],'',data['funded_by'],
data['e_mail2'],data['current_work'],"yes",data['date_stay_at_mpiwg'],data['group'],"no",data['current_work'])	data['e_mail2'],data['current_work'],"yes",data['date_stay_at_mpiwg'],data['group'],"no",data['current_work'])

return result,msg	return result,msg

def updatePersonEntry(self,data,ignoreEntries=[]):	def updatePersonEntry(self,data,ignoreEntries=None):
"""update an person entry from data. but ignore all fields in ignore Entries"""	"""update an person entry from data. but ignore all fields in ignore Entries"""
	if ignoreEntries is None:
	ignoreEntries = []

ignoreEntries.append('current_work') # TODO:updatecurrent work	#ignoreEntries.append('current_work') # TODO:updatecurrent work
	logging.debug("updatePersonEntry: data=%s ignoreEntries=%s"%(repr(data),repr(ignoreEntries)))

if data['date_to']=="": # wenn date_to leer	if data['date_to']=="": # wenn date_to leer
data['date_to']="date_none"	data['date_to']="date_none"
Line 705 class MPIWGRoot(ZSQLExtendFolder):	Line 921 class MPIWGRoot(ZSQLExtendFolder):

columns=data.keys()	columns=data.keys()
for x in ignoreEntries:	for x in ignoreEntries:
logging.info("ign rem: %s"%x)	logging.debug("updatePersonEntry: ignoring %s"%x)
try: #falls in ignore entries felder sind, die nicht in columns sind, fange den fehler ab	try: #falls in ignore entries felder sind, die nicht in columns sind, fange den fehler ab
columns.remove(x)	columns.remove(x)
except:	except:
Line 739 class MPIWGRoot(ZSQLExtendFolder):	Line 955 class MPIWGRoot(ZSQLExtendFolder):
resultSet=self.REQUEST.SESSION['personal_www']['resultSet']	resultSet=self.REQUEST.SESSION['personal_www']['resultSet']
news=self.REQUEST.SESSION['personal_www']['news']	news=self.REQUEST.SESSION['personal_www']['news']
conflicts=self.REQUEST.SESSION['personal_www']['conflicts']	conflicts=self.REQUEST.SESSION['personal_www']['conflicts']
	logging.debug("updatePersonalwww_doIt: args=%s\n resultSet=%s\n news=%s\n conflicts=%s"%(args,resultSet,news,conflicts))

ret="<html><body>"	ret="<html><body>"
# generate the new entry	# generate the new entry

Line 746 class MPIWGRoot(ZSQLExtendFolder):	Line 964 class MPIWGRoot(ZSQLExtendFolder):
ret+="<h2>Hinzugefügt</h2>"	ret+="<h2>Hinzugefügt</h2>"
ret+="<p>Neueinträge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"	ret+="<p>Neueinträge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"
ret+="<ul>"	ret+="<ul>"
for new in news:

	for new in news:
if args.has_key(self.urlQuote(new.encode('utf-8'))): # entry was selected	if args.has_key(self.urlQuote(new.encode('utf-8'))): # entry was selected
result,msg=self.generateNewPersonEntry(resultSet[new])	result,msg=self.generateNewPersonEntry(resultSet[new])
if not result:	if not result:
Line 755 class MPIWGRoot(ZSQLExtendFolder):	Line 973 class MPIWGRoot(ZSQLExtendFolder):
ret+="<li>ERROR: %s %s"%(new.encode('utf-8'),msg)	ret+="<li>ERROR: %s %s"%(new.encode('utf-8'),msg)
else:	else:
ret+="<li>OK: %s"%(new.encode('utf-8'))	ret+="<li>OK: %s"%(new.encode('utf-8'))

if news and (len(news)>0):	if news and (len(news)>0):
ret+="<p>Neueinträge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"	ret+="<p>Neueinträge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"
ret+="</ul>"	ret+="</ul>"
Line 773 class MPIWGRoot(ZSQLExtendFolder):	Line 992 class MPIWGRoot(ZSQLExtendFolder):
if args[conflict.encode('utf-8')+'_'+cf[0]]=="stored": #use the stored one	if args[conflict.encode('utf-8')+'_'+cf[0]]=="stored": #use the stored one
ignoreEntries.append(cf[0]) #so ignore field cf[0]	ignoreEntries.append(cf[0]) #so ignore field cf[0]
displayIgnored.append(cf)	displayIgnored.append(cf)

if len(displayIgnored)>0:	if len(displayIgnored)>0:
ret+="<h3>%s</h3>"%conflict.encode('utf-8')	ret+="<h3>%s</h3>"%conflict.encode('utf-8')

ret+="<table border='1'>"	ret+="<table border='1'>"
for iE in displayIgnored:	for iE in displayIgnored:
ret+="<tr><td>%s</td><td>%s</td><td>%s</td>"%(iE[0].encode('utf-8'),iE[1].encode('utf-8'),iE[2].encode('utf-8'))	ret+="<tr><td>%s</td><td>%s</td><td>%s</td>"%(iE[0].encode('utf-8'),iE[1].encode('utf-8'),iE[2].encode('utf-8'))
ret+="</tabel>"	ret+="</table>"

self.updatePersonEntry(resultSet[conflict],ignoreEntries=ignoreEntries)	self.updatePersonEntry(resultSet[conflict],ignoreEntries=ignoreEntries)

Line 798 class MPIWGRoot(ZSQLExtendFolder):	Line 1017 class MPIWGRoot(ZSQLExtendFolder):
return "<html><body>DONE</body></html>"	return "<html><body>DONE</body></html>"




def updatePersonalwww_html(self):	def updatePersonalwww_html(self):
"""update form for the homepages web form"""	"""update form for the homepages web form"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','updatePersonalwww.zpt')).__of__(self)	pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','updatePersonalwww.zpt')).__of__(self)
Line 830 class MPIWGRoot(ZSQLExtendFolder):	Line 1051 class MPIWGRoot(ZSQLExtendFolder):
try:	try:

self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])	self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
	logger("MPIWG Root (reindexCatalog: projects)",logging.INFO,"DONE")
	except:
	logger("MPIWG Root (reindexCatalog: projects)",logging.WARNING," %s %s"%sys.exc_info()[:2])

	try:

	self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
	logger("MPIWG Root (reindexCatalog: members)",logging.INFO,"DONE")
	except:
	logger("MPIWG Root (reindexCatalog: members)",logging.WARNING," %s %s"%sys.exc_info()[:2])

	try:

	self.fulltextProjectsMembers.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
	logger("MPIWG Root (reindexCatalog: fulltextProjectsMembers)",logging.INFO,"DONE")
except:	except:
logger("MPIWG Root (updatehomepage)",logging.WARNING," %s %s"%sys.exc_info()[:2])	logger("MPIWG Root (reindexCatalog: fulltextProjectsMembers)",logging.WARNING," %s %s"%sys.exc_info()[:2])




Line 847 class MPIWGRoot(ZSQLExtendFolder):	Line 1084 class MPIWGRoot(ZSQLExtendFolder):
#ret=[]	#ret=[]

def sorter(x,y):	def sorter(x,y):
return cmp(x[0],y[0])	return cmp(x[0].lower(),y[0].lower())

results=self.MembersCatalog({'isPublished':True})	results=self.MembersCatalog({'isPublished':True})

ret=[(", ".join([proj.lastName, proj.firstName]).decode('utf-8'),proj.getKey) for proj in results]	ret=[(unicodify(", ".join([proj.lastName, proj.firstName])), proj.getKey) for proj in results]

ret.sort(sorter)	ret.sort(sorter)
return ret	return ret
Line 880 class MPIWGRoot(ZSQLExtendFolder):	Line 1117 class MPIWGRoot(ZSQLExtendFolder):
<channel>"""	<channel>"""

for obj in self.getTree(dep, date, onlyActive, onlyArchived):	for obj in self.getTree(dep, date, onlyActive, onlyArchived):
linkStr="""<link>http://wwwneu.mpiwg-berlin.mpg.de/en/research/projects/%s</link>"""	linkStr="""<link>http://www.mpiwg-berlin.mpg.de/en/research/projects/%s</link>"""
rss+="""<item>"""	rss+="""<item>"""
rss+=linkStr%obj[3].getId()	rss+=linkStr%obj[3].getId()
rss+="""</item>"""	rss+="""</item>"""
Line 904 class MPIWGRoot(ZSQLExtendFolder):	Line 1141 class MPIWGRoot(ZSQLExtendFolder):
onlyArchived=0: alle Projekte	onlyArchived=0: alle Projekte
onlyArchived= 1 : nur aktuelle Projekte	onlyArchived= 1 : nur aktuelle Projekte
onlyArchived = 2: nur archivierte Projekte	onlyArchived = 2: nur archivierte Projekte

	department fuer das Tree geholt werden soll
"""	"""

returnListTmp=[]	returnListTmp=[]
Line 923 class MPIWGRoot(ZSQLExtendFolder):	Line 1162 class MPIWGRoot(ZSQLExtendFolder):
if idNr[0]=="x": # kompatibilitaet mit alter Konvention, x vor der Nummer macht project inactive	if idNr[0]=="x": # kompatibilitaet mit alter Konvention, x vor der Nummer macht project inactive
project[0].setActiveFlag(False)	project[0].setActiveFlag(False)

if (not dep) or (idNr[0]==dep): #falls dep gesetzt ist nur dieses hinzufuegen.	if (not dep) or (splittedId[0]==dep): #falls dep gesetzt ist nur dieses hinzufuegen.

if (onlyActive==0):	if (onlyActive==0):
returnListTmp.append((depth,nr,title,project[0]))	returnListTmp.append((depth,nr,title,project[0]))
Line 985 class MPIWGRoot(ZSQLExtendFolder):	Line 1224 class MPIWGRoot(ZSQLExtendFolder):
hashList={}	hashList={}
onlyArchived=int(form.get("onlyArchived",0))	onlyArchived=int(form.get("onlyArchived",0))
onlyActive=int(form.get("onlyActive",0))	onlyActive=int(form.get("onlyActive",0))
	dep=form.get("dep",None)

	fields=self.getTree(dep=dep,onlyArchived=onlyArchived,onlyActive=onlyActive)
fields=self.getTree(onlyArchived=onlyArchived,onlyActive=onlyActive)

logging.info("GOT TREE!----------------------------------------------------")	logging.info("GOT TREE!----------------------------------------------------")
for field in form.keys():	for field in form.keys():
Line 1004 class MPIWGRoot(ZSQLExtendFolder):	Line 1243 class MPIWGRoot(ZSQLExtendFolder):
else:	else:
fields[nr][3].setActiveFlag(False)	fields[nr][3].setActiveFlag(False)

#nummer hat sich ge�ndert	#nummer hat sich geaendert

entryChanged = False;	entryChanged = False;

	if isinstance(fields[nr][3].xdata_05,list): #for some reasons somtimes the content of the field is a list with one entry.
	fields[nr][3].xdata_05=fields[nr][3].xdata_05[0]

if not (fields[nr][3].xdata_05==form[str(nr)+'_number']):	if not (fields[nr][3].xdata_05==form[str(nr)+'_number']):
logging.info("Changed!Number+++++++++++++++++++++++++++++++++")	logging.info("Changed!Number+++++++++++++++++++++++++++++++++")
	logging.info(repr(fields[nr][3].xdata_05)+" ---> "+ repr(form[str(nr)+'_number']))
fields[nr][3].xdata_05=form[str(nr)+'_number']	fields[nr][3].xdata_05=form[str(nr)+'_number']
entryChanged = True	entryChanged = True

#completed har sich geaendert	#completed har sich geaendert

if not (fields[nr][3].getCompletedAt()==fields[nr][3].transformDate(form[str(nr)+'_completed'])):	td = fields[nr][3].transformDate # hole die funktion zum transformieren des datums

	if not (td(fields[nr][3].getCompletedAt())==td(form[str(nr)+'_completed'])):
fields[nr][3].setCompletedAt(form[str(nr)+'_completed'])	fields[nr][3].setCompletedAt(form[str(nr)+'_completed'])
	logging.info(repr(td(fields[nr][3].getCompletedAt()))+" ---> "+ repr(td(form[str(nr)+'_completed'])))
logging.info("Changed!Completed+++++++++++++++++++++++++++++++++")	logging.info("Changed!Completed+++++++++++++++++++++++++++++++++")
entryChanged = True	entryChanged = True

if not (fields[nr][3].getStartedAt()==fields[nr][3].transformDate(form[str(nr)+'_started'])):	if not (td(fields[nr][3].getStartedAt())==td(form[str(nr)+'_started'])):
fields[nr][3].setStartedAt(form[str(nr)+'_started'])	fields[nr][3].setStartedAt(form[str(nr)+'_started'])

	logging.info(repr(td(fields[nr][3].getStartedAt()))+" ---> "+ repr(td(form[str(nr)+'_started'])))
logging.info("Changed!Started+++++++++++++++++++++++++++++++++")	logging.info("Changed!Started+++++++++++++++++++++++++++++++++")
entryChanged = True	entryChanged = True

Line 1081 class MPIWGRoot(ZSQLExtendFolder):	Line 1328 class MPIWGRoot(ZSQLExtendFolder):

if key=="":	if key=="":
return ""	return ""
	try:
	key=utf8ify(key)
catalogged=self.MembersCatalog({'getKey':key})	catalogged=self.MembersCatalog({'getKey':key})
if len(catalogged)==0:	if len(catalogged)==0:
return ""	return ""
else:	else:
return catalogged[0].getObject().getId()	return catalogged[0].getObject().getId()

	except:
	return ""



Line 1094 class MPIWGRoot(ZSQLExtendFolder):	Line 1345 class MPIWGRoot(ZSQLExtendFolder):
"""give tuple member /projects"""	"""give tuple member /projects"""
ret=[]	ret=[]
members=self.getAllMembers()	members=self.getAllMembers()
	logging.debug("X %s"%repr(members))
#return str(members)	#return str(members)
for x in members:	for x in members:
	#logging.debug("X %s"%repr(x))
projects=self.getProjectsOfMember(key=x[1],date=date)	projects=self.getProjectsOfMember(key=x[1],date=date)
if len(projects)>0:	if len(projects)>0:
ret.append((x[0],projects))	ret.append((x[0],projects))
Line 1120 class MPIWGRoot(ZSQLExtendFolder):	Line 1372 class MPIWGRoot(ZSQLExtendFolder):

ret=[]	ret=[]
if key:	if key:
proj=self.ProjectCatalog({'getPersonKeyList':key})	logging.debug("MPIWGROOT (getProjectsOfMember):"+key)
	proj=self.ProjectCatalog({'getPersonKeyList':utf8ify(key)})
else:	else:
return ret # key muss definiert sein	return ret # key muss definiert sein

	#logging.debug("MPIWGROOT (getProjectsOfMember):"+repr(proj))
if proj:	if proj:
proj2=[]	proj2=[]
for x in proj:	for x in proj:
	#logging.error("proj:%s"%repr(x.getPath()))
if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):	if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):
proj2.append(x)	proj2.append(x)

Line 1139 class MPIWGRoot(ZSQLExtendFolder):	Line 1393 class MPIWGRoot(ZSQLExtendFolder):
proj2.sort(sortP)	proj2.sort(sortP)

projectListe=[]	projectListe=[]
	#logging.error("getprojectsofmember proj2: %s"%repr(proj2))
for proj in proj2:	for proj in proj2:
obj=proj.getObject()	obj=proj.getObject()
add=False	add=False
Line 1167 class MPIWGRoot(ZSQLExtendFolder):	Line 1421 class MPIWGRoot(ZSQLExtendFolder):
if add:	if add:
projectListe.append(obj)	projectListe.append(obj)

	#logging.error("getprojectsofmember projectliste: %s"%repr(projectListe))
return projectListe	return projectListe

def givePersonList(self,name):	def givePersonList(self,name):
Line 1364 class MPIWGRoot(ZSQLExtendFolder):	Line 1618 class MPIWGRoot(ZSQLExtendFolder):
return "done"	return "done"


	def sortResults(self,results):
	"""search the catalog and give results back sorted by meta_type"""
	ret = {}
	logging.debug(results())
	for result in results():
	metaType = result.meta_type
	resultList= ret.get(metaType,[])
	resultList.append(result)
	ret[metaType]=resultList

	logging.debug(ret)
	return ret


def manage_addMPIWGRootForm(self):	def manage_addMPIWGRootForm(self):
"""form for adding the root"""	"""form for adding the root"""

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

Removed from v.1.1.2.9
changed lines
	Added in v.1.1.2.42