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.1 and 1.1.2.29

version 1.1.2.1, 2008/06/24 11:16:27	version 1.1.2.29, 2010/09/22 16:06:09
Line 30 import updatePersonalWWW	Line 30 import updatePersonalWWW
import MPIWGStaff	import MPIWGStaff
from MPIWGHelper import *	from MPIWGHelper import *


	def sortWeight(x,y):
	x1=int(getattr(x[1],'weight','0'))
	y1=int(getattr(y[1],'weight','0'))
	return cmp(x1,y1)


class MPIWGRoot(ZSQLExtendFolder):	class MPIWGRoot(ZSQLExtendFolder):
"""Stammordner fuer den Web-Server"""	"""Stammordner fuer den Web-Server"""

fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',	meta_type='MPIWGRoot'
'xdata_03':'Historical Persons','xdata_04':'Time period',
'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',
'xdata_08':'Other involved scholars' ,'xdata_09':'Disciplines','xdata_10':'Themes',
'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',
'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',
'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}

	fieldLabels={'WEB_title':'WEB_Title',
	'xdata_01':'Responsible Scientists',
	'xdata_02':'Department',
	'xdata_03':'Historical Persons',
	'xdata_04':'Time period',
	'xdata_05':'Sorting number',
	'xdata_06':'Keywords',
	'xdata_07':'Short title',
	'xdata_08':'Other involved scholars' ,
	'xdata_09':'Disciplines',
	'xdata_10':'Themes',
	'xdata_11':'Object Digitallibrary',
	'xdata_12':'Cooperation partners',
	'xdata_13':'Funding institutions',
	'WEB_project_header':'WEB_project_header',
	'WEB_project_description':'WEB_project_description',
	'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 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]

	txt=obj.harvest_page()
	if not txt:
	return ret
	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 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):
	"""tranformiere alle Bilder in die Margins"""
	projects=self.getTree()
	ret=""
	for project in projects:
	proj=project[3]
	try:
	persons=proj.copyImageToMargin();
	except:
	logging.error("Cannnot do: %s"%repr(project))

def transformProjectsToId(self):	def transformProjectsToId(self):
"""trnasformiere zu ID, Hilfsfunktion die die alten Templates analysiert und mit der neuen Liste	"""trnasformiere zu ID, Hilfsfunktion die die alten Templates analysiert und mit der neuen Liste
Line 50 class MPIWGRoot(ZSQLExtendFolder):	Line 183 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'):
proj.responsibleScientistsList=[]	proj.responsibleScientistsList=[]

for person in persons.items():	for person in persons.items():
logging.info("XXXX"+repr(person))
if len(person[1]) >1: #nicht eindeutig	if len(person[1]) >1: #nicht eindeutig
ret+="nicht eindeutig --- %s: %s\n"%(proj.getId(),person[0])	ret+="nicht eindeutig --- %s: %s\n"%(proj.getId(),person[0])

Line 68 class MPIWGRoot(ZSQLExtendFolder):	Line 202 class MPIWGRoot(ZSQLExtendFolder):

return ret	return ret


def harvestProjects(self):	def harvestProjects(self):
"""harvest"""	"""harvest"""
folder="/tmp"	folder="/tmp"
Line 87 class MPIWGRoot(ZSQLExtendFolder):	Line 222 class MPIWGRoot(ZSQLExtendFolder):

def decode(self,str):	def decode(self,str):
"""decoder"""	"""decoder"""

if not str:	if not str:
return ""	return ""
if type(str) is StringType:	if type(str) is StringType:
Line 105 class MPIWGRoot(ZSQLExtendFolder):	Line 241 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 207 class MPIWGRoot(ZSQLExtendFolder):	Line 346 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 222 class MPIWGRoot(ZSQLExtendFolder):	Line 356 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 263 class MPIWGRoot(ZSQLExtendFolder):	Line 381 class MPIWGRoot(ZSQLExtendFolder):
return True	return True
return False	return False

def getSection(self):
"""returns the current section name"""	def getSections(self):
root = self.absolute_url()	"""returns a list of all sections i.e. top-level MPIWGFolders"""
url = self.REQUEST['URL']	secs = self.objectItems(['MPIWGFolder'])
if not url:	secs.sort(sortWeight)
return None	#logging.debug("root: %s secs: %s"%(repr(self.absolute_url()), repr(secs)))
path = string.replace(url, root, '')	# return pure list of objects
paths = path.split('/')	return [s[1] for s in secs]
if len(paths) > 0:
sec = paths[1]
if sec.find('.') < 0:
return sec
else:
return None
return None

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 286 class MPIWGRoot(ZSQLExtendFolder):	Line 397 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 310 class MPIWGRoot(ZSQLExtendFolder):	Line 437 class MPIWGRoot(ZSQLExtendFolder):
def replaceNotEmpty(self,format,field):	def replaceNotEmpty(self,format,field):
"""replace not empty"""	"""replace not empty"""
if field and (not field.lstrip()==''):	if field and (not field.lstrip()==''):
return format%field	return self.decode(format%field)
else:	else:
return ""	return ""


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 472 class MPIWGRoot(ZSQLExtendFolder):	Line 600 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,disciplineList,themesList,connection_id,lang=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
	if lang is not None:
	self.lang = lang

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



def getContexts(self,childs=None,parents=None,depth=None,date=None,onlyActive=True):	def getContexts(self,childs=None,parents=None,depth=None,date=None,onlyActive=True):
"""childs alle childs, alle parents"""	"""childs alle childs, alle parents"""
ret=[]	ret=[]

if parents:	if parents:
splitted=parents.split(".")	pnums=parents.split(".")
parentId=string.join(splitted[0:len(splitted)-1],".")	while len(pnums) > 1:
	pnums.pop()
	parentId=string.join(pnums,".")

for project in self.getProjectFields('xdata_05',sort='int',date=date):	for project in self.getProjectFields('xdata_05',sort='int',date=date):
if project[1]==parentId:	if project[1]==parentId:
ret.append(project)	ret.append(project)

	if (depth is not None) and (len(ret) >= depth):
	break

if childs:	if childs:
for project in self.getProjectFields('xdata_05',sort='int',date=date):	for project in self.getProjectFields('xdata_05',sort='int',date=date):
searchStr=childs+"(\..*)"	searchStr=childs+"(\..*)"
Line 510 class MPIWGRoot(ZSQLExtendFolder):	Line 644 class MPIWGRoot(ZSQLExtendFolder):
ret.append(project)	ret.append(project)
else:	else:
ret.append(project)	ret.append(project)

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

return ret	return ret


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 556 class MPIWGRoot(ZSQLExtendFolder):	Line 694 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 652 class MPIWGRoot(ZSQLExtendFolder):	Line 779 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 676 class MPIWGRoot(ZSQLExtendFolder):	Line 806 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 710 class MPIWGRoot(ZSQLExtendFolder):	Line 840 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 717 class MPIWGRoot(ZSQLExtendFolder):	Line 849 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 726 class MPIWGRoot(ZSQLExtendFolder):	Line 858 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 744 class MPIWGRoot(ZSQLExtendFolder):	Line 877 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'))
Line 769 class MPIWGRoot(ZSQLExtendFolder):	Line 902 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 801 class MPIWGRoot(ZSQLExtendFolder):	Line 936 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:	except:
logger("MPIWG Root (updatehomepage)",logging.WARNING," %s %s"%sys.exc_info()[:2])	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:
	logger("MPIWG Root (reindexCatalog: fulltextProjectsMembers)",logging.WARNING," %s %s"%sys.exc_info()[:2])



Line 822 class MPIWGRoot(ZSQLExtendFolder):	Line 972 class MPIWGRoot(ZSQLExtendFolder):

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 844 class MPIWGRoot(ZSQLExtendFolder):	Line 994 class MPIWGRoot(ZSQLExtendFolder):
else:	else:
return entry	return entry

	def getTreeRSS(self,dep=None,date=None,onlyActive=1,onlyArchived=0):
	"""generateTree"""
	rss="""<?xml version="1.0" encoding="utf-8"?>
	<rss version="2.0">
	<channel>"""

	for obj in self.getTree(dep, date, onlyActive, onlyArchived):
	linkStr="""<link>http://www.mpiwg-berlin.mpg.de/en/research/projects/%s</link>"""
	rss+="""<item>"""
	rss+=linkStr%obj[3].getId()
	rss+="""</item>"""
	if hasattr(obj[3],'publicationList'):
	rss+="""<item>"""
	rss+=linkStr%(obj[3].getId()+"/publicationList");
	rss+="""</item>"""
	rss+="""</channel>
	</rss>"""


	return rss

def getTree(self,dep=None,date=None,onlyActive=0,onlyArchived=0):	def getTree(self,dep=None,date=None,onlyActive=0,onlyArchived=0):
"""generate Tree from project list	"""generate Tree from project list
Line 855 class MPIWGRoot(ZSQLExtendFolder):	Line 1025 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 874 class MPIWGRoot(ZSQLExtendFolder):	Line 1046 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 936 class MPIWGRoot(ZSQLExtendFolder):	Line 1108 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 955 class MPIWGRoot(ZSQLExtendFolder):	Line 1127 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 (td(fields[nr][3].getStartedAt())==td(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+++++++++++++++++++++++++++++++++")
	entryChanged = True


if entryChanged:	if entryChanged:
logging.info("Changed!+++++++++++++++++++++++++++++++++")	logging.info("Changed!+++++++++++++++++++++++++++++++++")
Line 1027 class MPIWGRoot(ZSQLExtendFolder):	Line 1212 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 ""


# def getMembersFromList(self,list):
# """get member names from person full text list"""
# memberlist=[]
# persons=list.split(";")
# for person in persons:
# if len(person)>1: #nicht nur Trennzeichen
# splitted=person.split(",")
# if len(splitted)==1:
# splitted=person.lstrip().rstrip().split(" ")
# splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
# if splittedNew[0]=='':
# del splittedNew[0]
# search=string.join(splittedNew,' AND ')
#
# if not search=='':
# try:
#
# member=self.MembersCatalog({'title':search})
#
# except:
# member=None
# if member:
# logging.error("search publ %s:"%member[0].getObject().isPublished())
# if member and (member[0].getObject().isPublished()):
# if person =="Otto Sibum" : person="H. Otto Sibum"
# if person =="Norton Wise" : person="M. Norton Wise"
#
# #memberlist.append("<a href=%s >%s</a>"%(member[0].absolute_url,person.encode('utf-8')))
# memberlist.append((person, member[0].getObject().getId()))
# else:
# #memberlist.append("%s"%person.encode('utf-8'))
# memberlist.append((person,None))
# return memberlist

# def getUrlFromPerson(self,list):
# """get urls to person list"""
# ret=[]
# persons=list.split(";")
# for person in persons:
#
# if len(person)>1: #nicht nur Trennzeichen
# splitted=person.split(",")
# if len(splitted)==1:
# splitted=person.lstrip().rstrip().split(" ")
# splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
# if splittedNew[0]=='':
# del splittedNew[0]
# search=string.join(splittedNew,' AND ')
#
# if not search=='':
#
# try:
# proj=self.MembersCatalog({'title':search})
# except:
# proj=None
#
# if proj and (proj[0].getObject().isPublished()):
# if person =="Otto Sibum" : person="H. Otto Sibum"
# if person =="Norton Wise" : person="M. Norton Wise"
# #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
# if self.MPIWGrootURL().split("/")[-1]=='en':
# tmpPath="/en/staff/members/"
# else:
# tmpPath="/de/mitarbeiter/members/"
# ret.append("<a href=%s >%s</a>"%(tmpPath+proj[0].getObject().getId()+"/index.html",person))
# else:
# #ret.append("%s"%person.encode('utf-8'))
# ret.append("%s"%person)
# return string.join(ret,";")
#
def getProjectsOfMembers(self,date=None):	def getProjectsOfMembers(self,date=None):
"""give tuple member /projects"""	"""give tuple member /projects"""
ret=[]	ret=[]
members=self.getAllMembers()	members=self.getAllMembers()
	logging.error("X %s"%repr(members))
#return str(members)	#return str(members)
for x in members:	for x in members:
	logging.error("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 1135 class MPIWGRoot(ZSQLExtendFolder):	Line 1256 class MPIWGRoot(ZSQLExtendFolder):

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

Line 1143 class MPIWGRoot(ZSQLExtendFolder):	Line 1264 class MPIWGRoot(ZSQLExtendFolder):
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 1154 class MPIWGRoot(ZSQLExtendFolder):	Line 1276 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 1182 class MPIWGRoot(ZSQLExtendFolder):	Line 1304 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):

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

Removed from v.1.1.2.1
changed lines
	Added in v.1.1.2.29