"""This contains the class MPIWG Projects
for organizing and maintaining the different project pages
"""
#TODO: mechanismus fur links to personen ueberarbeiten, da jetzt alle e_mails als members auftauchen unabhaengig vom status publish_the_data
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
from Products.ZCatalog.CatalogPathAwareness import CatalogAware
from OFS.Image import Image
from Globals import package_home
import urllib
import MPIWGStaff
import string
import re
import os
from types import *
import zLOG
import xmlhelper # Methoden zur Verwaltung der projekt xml
from OFS.SimpleItem import SimpleItem
from OFS.Folder import Folder
from Products.ZSQLMethods.SQL import SQLConnectionIDs
from AccessControl import ClassSecurityInfo
from bibliography import *
import time
import xml.dom.minidom
import sys
definedFields=['WEB_title','xdata_01','xdata_02','xdata_03','xdata_04','xdata_05','xdata_06','xdata_07','xdata_08','xdata_09','xdata_10','xdata_11','xdata_12','xdata_13','WEB_project_header','WEB_project_description','WEB_related_pub']
checkFields = ['xdata_01']
def getTextFromNode(nodename):
nodelist=nodename.childNodes
rc = ""
for node in nodelist:
if node.nodeType == node.TEXT_NODE:
rc = rc + node.data
return rc
def sortF(x,y):
try:
return cmp(x[1],y[1])
except:
try:
return cmp(str(x[1]),str(y[1]))
except:
return 0
def sortI(x,y):
xsplit=x[1].split(".")
ysplit=y[1].split(".")
xret=""
yret=""
try:
for i in range(5):
try:
yret=yret+"%04i"%int(xsplit[i])
except:
yret=yret+"%04i"%0
try:
xret=xret+"%04i"%int(ysplit[i])
except:
xret=xret+"%04i"%0
return cmp(int(yret),int(xret))
except:
return cmp(x[1],y[1])
class MPIWGLink(SimpleItem):
"""create a symbolic link to another page"""
meta_type="MPIWGLink"
def isActiveItem(self):
"""teste ob ausgewaehlt"""
#url1 beim link anstelle von url1, da link jeweils index_html als url hat.
if self.absolute_url()==self.REQUEST['URL1']:
return "aktiv"
else:
return ""
def __init__(self,id,link,title='',weight=''):
"""init mpiwglink"""
self.id=id
self.link=link
self.title=title
self.weight=weight
def getObj(self):
"""bekomme original"""
## objpath=self.link.replace("/",".")
## if objpath[0]!=".":
## objpath="."+objpath
## print objpath
## return eval("self"+objpath)
splitted=self.link.lstrip().split("/")
obj=self
for x in splitted:
if not x=="":
obj=getattr(obj,x)
return obj
def getWeight(self):
if self.linkWeight and linkWeight!="":
return self.linkWeight
else:
return self.getObj().weight
manage_options=SimpleItem.manage_options+(
{'label':'main config','action':'changeLinkForm'},
)
def changeLinkForm(self):
"""change MPIWG link"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGLinkChange.zpt')).__of__(self)
return pt()
def changeLink(self,link,title,weight,RESPONSE=None):
"""change links"""
self.link=link
self.title=title
self.weight=weight
if RESPONSE is not None:
RESPONSE.redirect('manage')
def index_html(self):
"""index"""
return self.getObj().pt_render(extra_context={'here':self})
def manage_addMPIWGLinkForm(self):
"""Form for adding link"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGLink.zpt')).__of__(self)
return pt()
def manage_addMPIWGLink(self,id,link,title,weight,RESPONSE=None):
"""add link"""
newObj=MPIWGLink(id,link,title,weight)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class MPIWGTemplate(ZopePageTemplate):
"""Create a layout Template for different purposes"""
meta_type="MPIWGTemplate"
manage_options=ZopePageTemplate.manage_options+(
{'label':'Change Weight','action':'changeWeightForm'},
)
def changeWeightForm(self):
"""change weight form"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGTemplateChangeWeight.zpt')).__of__(self)
return pt()
def changeWeight(self,weight,RESPONSE=None):
"""change weight"""
self.weight=weight
if RESPONSE is not None:
RESPONSE.redirect('manage')
def __init__(self, id, text=None, content_type=None,MPIWGType=None):
self.id = str(id)
self.ZBindings_edit(self._default_bindings)
if text is None:
self._default_content_fn = os.path.join(package_home(globals()),
'zpt/MPIWG_%s_template_standard.zpt'%MPIWGType)
text = open(self._default_content_fn).read()
self.pt_edit(text, content_type)
"""change form"""
def isActiveItem(self):
"""teste ob ausgewaehlt"""
if self.absolute_url()==self.REQUEST['URL']:
return "aktiv"
else:
return ""
def manage_addMPIWGTemplateForm(self):
"""Form for adding"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGTemplate.zpt')).__of__(self)
return pt()
from urllib import quote
def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):
"Add a Page Template with optional file content."
if type(MPIWGType)==StringType:
MPIWGTypes=[MPIWGType]
else:
MPIWGTypes=MPIWGType
for singleType in MPIWGTypes:
if REQUEST is None:
self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))
ob = getattr(self, id)
if title:
ob.pt_setTitle(title)
return ob
else:
file = REQUEST.form.get('file')
headers = getattr(file, 'headers', None)
if headers is None or not file.filename:
zpt = MPIWGTemplate(id,MPIWGType=singleType)
else:
zpt = MPIWGTemplate(id, file, headers.get('content_type'))
self._setObject(id, zpt)
ob = getattr(self, id)
if title:
ob.pt_setTitle(title)
try:
u = self.DestinationURL()
except AttributeError:
u = REQUEST['URL1']
ob = getattr(self, id)
ob.weight=weight
REQUEST.RESPONSE.redirect(u+'/manage_main')
return ''
class MPIWGRoot(ZSQLExtendFolder):
"""Stammordner für den Web-Server"""
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'}
folders=['MPIWGProject','Folder','ECHO_Navigation']
meta_type='MPIWGRoot'
def versionHeaderEN(self):
"""version header text"""
date= self.REQUEST.get('date',None)
if date:
txt="""<h2>This pages shows the project which existed at %s</h2>"""%str(date)
return txt
return ""
def versionHeaderDE(self):
"""version header text"""
date= self.REQUEST.get('date',None)
if date:
txt="""<h2>Auf dieser Seite finden Sie die Projekte mit Stand vom %s</h2>"""%str(date)
return ""
def createOrUpdateId_raw(self):
"""create sequence to create ids for bibliography"""
debug=None
#suche groesste existierende id
founds=self.ZSQLQuery("select id from bibliography")
if founds:
ids=[int(x.id[1:]) for x in founds]
maximum=max(ids)
id_raw=self.ZSQLQuery("select nextval('id_raw_test')",debug=debug)
if id_raw:
self.ZSQLQuery("drop sequence id_raw_test",debug=debug)
self.ZSQLQuery("create sequence id_raw_test start %i"%(maximum+1),debug=debug)
def queryLink(self,link):
"""append querystring to the link"""
return "%s?%s"%(link,self.REQUEST.get('QUERY_STRING',''))
def getKategory(self,url):
"""kategorie"""
splitted=url.split("/")
return splitted[4]
def generateUrlProject(self,url,project=None):
"""erzeuge aus absoluter url, relative des Projektes"""
if project:
splitted=url.split("/")
length=len(splitted)
short=splitted[length-2:length]
base=self.REQUEST['URL3']+"/"+"/".join(short)
else:
findPart=url.find("/projects/")
base=self.REQUEST['URL1']+"/"+url[findPart:]
return base
def isNewCapital(self,text=None,reset=None):
if reset:
self.REQUEST['capital']="A"
return True
else:
if len(text)>0 and not (text[0]==self.REQUEST['capital']):
self.REQUEST['capital']=text[0]
return True
else:
return False
def subNav(self,obj):
"""return subnav elemente"""
def sortWeight(x,y):
x1=int(getattr(x[1],'weight','0'))
y1=int(getattr(y[1],'weight','0'))
return cmp(x1,y1)
#if obj.meta_type in ['MPIWGTemplate','MPIWGLink']:
# id=obj.aq_parent.getId()
#else:
#id=obj.getId()
#suche die zweite ebene
if not obj.aq_parent.getId() in ['de','en']:
obj=obj.aq_parent
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):
"""teste ob subnavigation aktiv"""
for part in self.REQUEST['URL'].split("/"):
if part==name:
return True
return False
def upDateSQL(self,fileName):
"""updates SQL databases using fm.jar"""
fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')
xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)
zLOG.LOG("MPIWG Web",zLOG.INFO,"java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath))
ret=os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()
zLOG.LOG("MPIWG Web",zLOG.INFO,"result convert: %s"%ret)
return 1
def patchProjects(self,RESPONSE):
"""patch"""
projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
for project in projects:
tmp=project[1].WEB_project_description[0].replace("/CD/projects/","")[0:]
setattr(project[1],'WEB_project_description',[tmp[0:]])
RESPONSE.write("<p>%s</p>\n"%project[0])
def replaceNotEmpty(self,format,field):
"""replace not empty"""
if field and (not field.lstrip()==''):
return format%field
else:
return ""
def isActual(self,project):
"""checke if project is actual"""
actualTime=time.localtime()
obj= project.getObject()
if getattr(obj,'archiveTime',actualTime)< actualTime:
return False
else:
return True
def redirectIndex_html(self,request):
#return request['URL1']+'/index_html'
return urllib.urlopen(request['URL1']+'/index_html').read()
def formatBibliography(self,here,found):
"""format"""
return formatBibliography(here,found)
def getValue(self,fieldStr):
"""Inhalt des Feldes"""
if type(fieldStr)==StringType:
field=fieldStr
else:
field=fieldStr[0]
try:
if field[len(field)-1]==";":
field=field[0:len(field)-1]
except:
"""nothing"""
field=re.sub(r';([^\s])','; \g<1>',field)
return field.encode('utf-8')
def sortedNames(self,list):
"""sort names"""
def sortLastName(x_c,y_c):
try:
x=urllib.unquote(x_c).encode('utf-8','ignore')
except:
x=urllib.unquote(x_c)
try:
y=urllib.unquote(y_c).encode('utf-8','ignore')
except:
x=urllib.unquote(y_c)
try:
last_x=x.split()[len(x.split())-1]
last_y=y.split()[len(y.split())-1]
except:
last_x=""
last_y=""
if last_x<last_y:
return 1
elif last_x>last_y:
return -1
else:
return 0
list.sort(sortLastName)
list.reverse()
return list
def __init__(self, id, title):
"""init"""
self.id=id
self.title=title
def urlQuote(self,str):
"""quote"""
return urllib.quote(str)
def urlUnQuote(self,str):
"""quote"""
return urllib.unquote(str)
def harvestHistoricalPersons(self):
"""erstelle liste aller erwaehnten actors"""
def normalize(str):
"""loesche fuhrendes space"""
if (len(str)>1) and (str[0]==" "):
ret=str[1:]
else:
ret=str
return ret
list={}
projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
for project in projects:
lg=len(project[1].xdata_03[0])-1
if (lg>1) and (project[1].xdata_03[0][lg]==";"):
project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]
try:
if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;
for person in project[1].xdata_03[0].split(";"):
personNormal=normalize(person)
if personNormal in list.keys():
list[urllib.quote(personNormal)][1].append(project[1])
else:
list[urllib.quote(personNormal)]=(personNormal,[project[1]])
else: #guess , is sepeator
for person in project[1].xdata_03[0].split(","):
personNormal=normalize(person)
if urllib.quote(personNormal) in list.keys():
list[urllib.quote(personNormal)][1].append(project[1])
else:
list[urllib.quote(personNormal)]=(personNormal,[project[1]])
except:
zLOG.LOG("MPIWG Web (harvestHistoricalPerson)",zLOG.ERROR,"cannot annalyize: %s"%repr(project))
return list
def storeHistoricalPersons(self,RESPONSE=None):
"""store persons"""
self.personDict={}
personDict=self.harvestHistoricalPersons()
for person in personDict.keys():
for project in personDict[person][1]:
if person in self.personDict.keys():
self.personDict[person][1].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))
else:
self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])
if RESPONSE is not None:
RESPONSE.redirect("showHistoricalPersons")
def getPersonDict(self,name):
"""name von dict"""
try:
return self.personDict[name][0].encode('utf-8')
except:
return self.personDict[name][0]
return self.personDict[name][0].decode('latin-1').encode('utf-8')
def showHistoricalPersons(self):
"""show persons"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showHistoricalPersons')).__of__(self)
return pt()
def editHistoricalPersonsForm(self):
"""edit historical persons for consistency"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalPersonsForm')).__of__(self)
return pt()
def getProjectsByFieldContent(self,fieldName,fieldContentsEntry, date=None):
"""gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""
def sort(x,y):
return cmp(x.WEB_title[0],y.WEB_title[0])
if type(fieldContentsEntry) is StringType:
fieldContentsTmp=[fieldContentsEntry]
else:
fieldContentsTmp=fieldContentsEntry
fieldContents=[]
for x in fieldContentsTmp:
fieldContents.append(" AND ".join(x.split()))
projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' AND')})
#print projects
#ret=[x for x in projects]
ret=[]
for x in projects:
obj=x.getObject()
obj=obj.getActualVersion(date)
if obj and (not getattr(obj,'invisible',None)):
#if not (x in ret):
ret.append(x)
ret.sort(sort)
return ret
def changeMPIWGRootForm(self):
"""edit"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)
return pt()
def changeMPIWGRoot(self,title,disciplineList,themesList,connection_id,RESPONSE=None):
"""change"""
self.title=title
self.connection_id=connection_id
self.disciplineList=disciplineList
self.themesList=themesList
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def getDisciplineList(self):
"""get disciplines as list"""
list= self.disciplineList.split("\n")
return [x.rstrip().lstrip() for x in list]
def getThemeList(self):
"""get themes as list"""
list= self.themesList.split("\n")
return [x.rstrip().lstrip() for x in list]
def test(self):
"""test"""
return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url
def getContexts(self,childs=None,parents=None,depth=None,date=None):
"""childs alle childs, alle parents"""
ret=[]
if parents:
splitted=parents.split(".")
parentId=string.join(splitted[0:len(splitted)-1],".")
for project in self.getProjectFields('xdata_05',sort='int',date=date):
if project[1]==parentId:
ret.append(project)
if childs:
for project in self.getProjectFields('xdata_05',sort='int',date=date):
searchStr=childs+"(\..*)"
if re.match(searchStr,project[1]):
if depth:
if int(depth)>=len(project[1].split("."))-len(childs.split(".")):
ret.append(project)
else:
ret.append(project)
return ret
def getProjectFields(self,fieldName,date=None,folder=None,sort=None):
"""getListofFieldNames"""
ret=[]
objects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'],search_sub=0)
for object in objects:
obj=object[1]
obj=obj.getActualVersion(date)
if obj and (not getattr(obj,'invisible',None)):
if fieldName=="WEB_title_or_short":
if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer
fieldNameTmp="WEB_title"
else:
fieldNameTmp="xdata_07"
else:
fieldNameTmp=fieldName
ret.append((obj,obj.getContent(fieldNameTmp)))
if sort=="int":
ret.sort(sortI)
else:
ret.sort(sortF)
return ret
def showNewProjects(self):
projects=[]
for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets
if objs[0].xdata_05 and (objs[0].xdata_05[0] == ""):
projects.append(objs)
return projects
manage_options = Folder.manage_options+(
{'label':'Update Personal Homepages','action':'updateHomepages'},
{'label':'Main config','action':'changeMPIWGRootForm'},
{'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
{'label':'Store Historical Persons','action':'storeHistoricalPersons'},
)
def importNamesForm(self):
"""Form"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGNamesForm.zpt')).__of__(self)
return pt()
def importNames(self,fileupload,folderName,RESPONSE=None):
"""import komma-sep list email,lastName,firstName"""
project=getattr(self,folderName)
load=fileupload.read()
for line in load.split('\r'):
splitted=line.split(",")
# print splitted
if not (splitted[0]==""):
newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])
try:
project._setObject(splitted[0],newObj)
#print "done:",splitted[0]
except:
zLOG.LOG("MPIWG Web (importNames)",zLOG.INFO,"cannot import: %s"%splitted[0])
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def updatePublicationDB(self,personId=None):
"""updates the publication db, i.e. copy year into the main table"""
if personId:
founds = self.ZSQLInlineSearch(_table="publications",id_main=personId)
else:
founds = self.ZSQLInlineSearch(_table="publications")
for found in founds:
if found.id_institutsbibliographie and (not found.id_institutsbibliographie ==""):
entries = self.ZSQLInlineSearch(_table="institutsbiblio",id=found.id_institutsbibliographie)
for entry in entries:
self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)
if found.id_gen_bib and (not found.id_gen_bib ==""):
entries = self.ZSQLInlineSearch(_table="bibliography",id=found.id_gen_bib)
for entry in entries:
self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)
return True
def updateHomepage_neu(self,RESPONSE=None):
""" update"""
RESPONSE.write("<html><body>\n")
url="http://itgroup.mpiwg-berlin.mpg.de:8050/FMPro?-db=personal-www&-format=-dso_xml&-lay=sql_export&-max=10000&-findall"
fh=urllib.urlopen(url)
dom=xml.dom.minidom.parse(fh)
memberFolder=getattr(self,'members')
members=memberFolder.ZopeFind(memberFolder,obj_metatypes=["MPIWGStaff"])
memberList=[x[0] for x in members]
for row in dom.getElementsByTagName('ROW'):
username=getTextFromNode(row.getElementsByTagName('username')[0])
id=getTextFromNode(row.getElementsByTagName('ID')[0])
name=getTextFromNode(row.getElementsByTagName('Name')[0])
vorname=getTextFromNode(row.getElementsByTagName('Vorname')[0])
title=getTextFromNode(row.getElementsByTagName('Title')[0])
e_mail=getTextFromNode(row.getElementsByTagName('e_mail')[0])
e_mail_p=getTextFromNode(row.getElementsByTagName('e_mail_p')[0])
date_from=getTextFromNode(row.getElementsByTagName('Date_from')[0])
date_to=getTextFromNode(row.getElementsByTagName('Date_to')[0])
abteilung=getTextFromNode(row.getElementsByTagName('Abteilung')[0])
heimat_inst=getTextFromNode(row.getElementsByTagName('heimat_inst')[0])
funded_by=getTextFromNode(row.getElementsByTagName('funded_by')[0])
e_mail2=getTextFromNode(row.getElementsByTagName('e_mail2')[0])
publish_the_data=getTextFromNode(row.getElementsByTagName('publish_the_data')[0])
cwNode=row.getElementsByTagName('current_work.current')[0]
cw=cwNode.getElementsByTagName('DATA')
if cw:
txt=getTextFromNode(cw[0])
else:
txt=""
cwNode=row.getElementsByTagName('current_work.publish')[0]
cw=cwNode.getElementsByTagName('DATA')
if cw:
txt_p=getTextFromNode(cw[0])
else:
txt_p=""
project=getattr(self,'members')
if not (username in memberList):#neuer eintrag
try:
newObj=MPIWGStaff.MPIWGStaff(str(username),name,vorname)
memberFolder._setObject(str(username),newObj)
RESPONSE.write("<p>new:%s</p>\n"%username.encode('utf-8'))
obj=getattr(memberFolder,username)
obj.createNewDBEntry(publish_the_data,id,name,
vorname,title,e_mail,
e_mail_p,date_from,date_to,
abteilung,heimat_inst,funded_by,
e_mail2,txt,txt_p)
except:
RESPONSE.write("<p>ERROR:%s %s %s</p>\n"%(username.encode('utf-8'),name.encode('utf-8'),vorname.encode('utf-8')))
RESPONSE.write("<p> : %s %s"%sys.exc_info()[:2])
else:
RESPONSE.write("<p>update:%s</p>\n"%username.encode('utf-8'))
self.ZSQLChange(_table="personal_www",_identify="id=%s"%id,publish_the_data=publish_the_data,
date_from=date_from,
date_to=date_to)
return True
def updateHomepages(self,RESPONSE):
"""lege members an"""
self.upDateSQL('personalwww.xml')
founds=self.ZSQLInlineSearch(_table='personal_www',publish_the_data='yes')
project=getattr(self,'members')
for found in founds:
if not (found.e_mail==""):
newObj=MPIWGStaff.MPIWGStaff(found.username,found.name,found.vorname)
try:
project._setObject(found.username,newObj)
RESPONSE.write("<p>new:%s</p>\n"%found.username)
except:
RESPONSE.write("<p>old:%s (%s,%s)</p>\n"%(found.username,found.name,found.vorname))
#delete non existing
foundUserNames=[x.username for x in founds]
for member in self.ZopeFind(self,obj_metatypes=["MPIWGStaff"],search_sub=1):
if member[1].getId() not in foundUserNames:
member[1].aq_parent.manage_delObjects(ids=[member[1].getId()])
RESPONSE.write("<p>deleted:%s</p>\n"%member[1].getId())
try:
self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
except:
pass
self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
self.updatePublicationDB()
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def getAllMembers(self):
"""give list of all members"""
ret=[]
#for x in self.members.objectValues('MPIWGStaff'):
#print x.title
# ret.append(x.title.decode('utf-8'))
for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):
ret.append(x[1].title.decode('utf-8'))
ret.sort()
#print ret
return ret
def printAllMembers(self):
"""prin"""
members=self.getAllMembers()
ret=""
for x in members:
ret+="<p>%s</p>"%x
return ret
def makeList(self,entry):
"""makes a list out of one entry or repeat a list"""
if type(entry) is StringType:
return [entry]
else:
return entry
def getTree(self,date=None):
"""generate Tree from project list"""
returnList=[]
for project in self.getProjectFields('xdata_05',sort="int",date=date): # get Projects sorted by xdata_05
for idNr in project[1].split(";"): # more than one number
if not idNr=="":
splittedId=idNr.split(".")
depth=len(splittedId)
nr=idNr
#title=project[0].WEB_title
title=[project[0].getContent('WEB_title')]
#print title
if idNr[0]!="x":
returnList.append((depth,nr,title,project[0]))
return returnList
def formatElementsAsList(self,elements):
"""formatiere tree als liste"""
actualDepth=0
ret=""
for element in elements:
if (element[0]>actualDepth):
#fuege soviele ul ein wie unterschied in tiefe
if element[0]==1:
ret+="""<div class="dept">\n<ul class="liste">\n"""
else:
for i in range(element[0]-actualDepth):
if i>0:
ret+="<li>"
ret+="""<ul class="liste">\n"""
actualDepth=element[0]
elif (element[0]<actualDepth):
#fuege soviele /ul ein wie unterschied in tiefe
for i in range(-element[0]+actualDepth):
ret+="<br><br></li></ul>\n"
#ret+="<br><br>\n</li>\n</ul>\n</li>\n"
if element[0]==1:
department=int(element[3].getContent('xdata_05'))-1
ret+="""</ul></div>\n"""
if department==4: #hack
department=3
ret+="""<div class="bildspalte"><img src="../grafik/dept%i.jpg" width="160" height="120" vspace="40"></div>
<div class="dept">\n<ul class="liste">\n
"""%department
actualDepth=element[0]
else:
ret+="""\n</li>\n"""
ret+="""<li>\n"""
if actualDepth==1:
departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'Ind. Research Group','5':'Ind. Research Group'}
department=element[3].getContent('xdata_05')
ret+="""<a href="#top"><img src="../grafik/totop.gif" vspace="10" border="0"></a><br><a name="dept%s"></a>%s: """%(department,departmentName[department])
if self.REQUEST.has_key('date'):
ret+="""<a href="%s?date=%s">%s</a>"""%(self.generateUrlProject(element[3].absolute_url())+"/index.html",self.REQUEST['date'],element[3].getContent('WEB_title'))
else:
ret+="""<a href="%s">%s</a>"""%(self.generateUrlProject(element[3].absolute_url())+"/index.html",element[3].getContent('WEB_title'))
return ret
def formatElementForOverview(self,element):
"""format the element for output in overview"""
if element[0]==1: #department
#print element[3].getContent('xdata_05')
if element[3].getContent('xdata_05') == "4":
return """<h2 class="hier"><a href="%s">Ind. Research Group I: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
if element[3].getContent('xdata_05') == "5":
return """<h2 class="hier"><a href="%s">Ind. Research Group II: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
return """<h2 class="hier"><a href="%s">Department %s: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('xdata_05'),element[3].getContent('WEB_title'))
elif element[0]==2: #mainprojects
return """<h3 class="hier"><a href="%s">%s</a></h3><p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
elif element[0]==3:
return """<p class="hier"><a href="%s">%s</a></p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
def changePosition(self,treeId,select,RESPONSE=None):
"""Change Postion Entry"""
numbers=[]
# Suche hoechste bisherige nummer
projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05
#print "pj",projects
for project in projects: #suche alle subtrees der treeId
#print treeId
founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])
if founds:
#print "x",founds.group(0),len(founds.group(0).split("."))
if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene
try:
numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))
except:
numbers.append(int(0))
try:
highest=max(numbers)
except:
highest=0
projects=self.showNewProjects()
for i in self.makeList(select):
highest+=10
projects[int(i)][0].xdata_05=treeId+"."+str(highest)
if RESPONSE is not None:
RESPONSE.redirect('showTree')
def changeTree(self,RESPONSE=None):
"""change the complete tree"""
form=self.REQUEST.form
hashList={}
fields=self.getTree()
for idNr in form.keys():
if not (fields[int(idNr)][3].xdata_05==form[idNr]):
fields[int(idNr)][3].xdata_05=form[idNr]
fields[int(idNr)][3].copyObjectToArchive()
if RESPONSE is not None:
RESPONSE.redirect('showTree')
def getProjectWithId(self,id):
fields=self.getProjectFields('xdata_05')
for field in fields:
if field[1]==id:
return field[0]
return None
def getRelativeUrlFromPerson(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.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:
#ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
ret.append("<a href=%s >%s</a>"%('members/'+proj[0].id+'/index.html',person))
else:
#ret.append("%s"%person.encode('utf-8'))
ret.append("%s"%person)
return string.join(ret,";")
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:
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')))
ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url+"/index.html",person))
else:
#ret.append("%s"%person.encode('utf-8'))
ret.append("%s"%person)
return string.join(ret,";")
def getProjectsOfMembers(self,date=None):
"""give tuple member /projects"""
ret=[]
members=self.getAllMembers()
#return str(members)
for x in members:
ret+=self.getProjectsOfMember(name=x,date=date)
return ret
def getProjectsOfMember(self,name=None,email=None,date=None):
"""get project of a member"""
def sortP(x,y):
"""sort by sorting number"""
#print x.xdata_05,y.xdata_05
return cmp(x.WEB_title,y.WEB_title)
ret=[]
splitNeu=[]
if email:
members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email],search_sub=1)
name = members[0][1].title.decode('utf-8')
y=name
splitted=y.split(",")
#XXXX
splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]
#for s in splitted:
# splitNeu.append("\""+s+"\"")
search=string.join(splitNeu,' AND ')
proj=self.ProjectCatalog({'xdata_01':search})
if proj:
proj2=[]
for x in proj:
if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):
if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):
proj2.append(x)
else:
proj2=[]
proj=self.ProjectCatalog({'xdata_08':search})
if proj:
names=[x.WEB_title for x in proj]
for x in proj:
if (not x.WEB_title in names) and (getattr(x.getObject(),'archiveTime','')==''):
proj2.append(x)
proj2.sort(sortP)
if len(proj2)>0:
ret.append((y,proj2))
return ret
def givePersonList(self,name):
"""check if person is in personfolder and return list of person objects"""
splitted=name.split(",")
if len(splitted)==1:
splitted=name.lstrip().rstrip().split(" ")
splittedNew=[split.lstrip() for split in splitted]
if splittedNew[0]=='':
del splittedNew[0]
search=string.join(splittedNew,' AND ')
if not search=='':
proj=self.MembersCatalog({'title':search})
if proj:
return [[x.lastName,x.firstName] for x in proj]
else:
return []
## splitted=name.split(",") # version nachname, vorname...
## if len(splitted)>1:
## lastName=splitted[0]
## firstName=splitted[1]
## else:
## splitted=name.split(" ") #version vorname irgenwas nachnamae
## lastName=splitted[len(splitted)-1]
## firstName=string.join(splitted[0:len(splitted)-1])
## objs=[]
#print self.members
## for x in self.members.__dict__:
## obj=getattr(self.members,x)
## if hasattr(obj,'lastName') and hasattr(obj,'firstName'):
## if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):
## objs.append((obj,lastName+", "+firstName))
return objs
def personCheck(self,names):
"""all persons for list"""
#print "names",names
splitted=names.split(";")
ret={}
for name in splitted:
if not (name==""):
try:
ret[name]=self.givePersonList(name)
except:
"""NOTHIHN"""
#print "RET",ret
return ret
def giveCheckList(self,person,fieldname):
"""return checklist"""
#print "GCL",fieldname
if fieldname=='xdata_01':
x=self.personCheck(person.getContent(fieldname))
#print "GCLBACKX",x
return x
def isCheckField(self,fieldname):
"""return chechfield"""
return (fieldname in checkFields)
def manage_addMPIWGRootForm(self):
"""form for adding the root"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)
return pt()
def manage_addMPIWGRoot(self,id,title,connection_id="",RESPONSE=None):
"""add a root folder"""
newObj=MPIWGRoot(id,title)
self._setObject(id,newObj)
ob=getattr(self,id)
setattr(ob,'connection_id',connection_id)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
class MPIWGProject_publication(SimpleItem):
"""publications object fuer project"""
meta_type="MPIWGProject_publication"
def editPublication(self,text=None,RESPONSE=None):
"""edit a publication"""
if (not text):
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
return pt()
self.text=text[0:]
if RESPONSE:
RESPONSE.redirect("../managePublications")
class MPIWGProject_image(Image):
"""Images for Projects"""
meta_type="MPIWGProject_image"
def showImage(self,imageUrl=None):
"""show Images at an extra page"""
self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
return pt()
def editImage(self,file=None,caption=None,RESPONSE=None):
"""edit the Image"""
if (not file) and (not caption):
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
return pt()
if file and (not file.filename.lstrip().rstrip()==""):
self.manage_upload(file)
if caption:
self.caption=caption[0:]
if RESPONSE:
RESPONSE.redirect("../manageImages")
class MPIWGProject(CatalogAware,Folder):
"""Class for Projects"""
security=ClassSecurityInfo()
meta_type='MPIWGProject'
default_catalog='ProjectCatalog'
def sortedByPlace(self,metatype):
"""find metatype and sort by place"""
def sort(x,y):
return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
founds=self.ZopeFind(self,obj_metatypes=[metatype]);
founds.sort(sort)
return founds
def copyPublicationsToList(self,RESPONSE=None):
"""copy publications in to list"""
publicationTxt=self.getContent('WEB_related_pub')
pubSplits=publicationTxt.split("<p>")
for pubSplit in pubSplits:
pubSplit=pubSplit.replace("</p>","")
self.addPublication(pubSplit)
if RESPONSE:
RESPONSE.redirect('managePublications')
def copyImageToMargin(self,RESPONSE=None):
"""copy inline images to marginal images"""
self.getContent('WEB_project_description',filter='yes')
filename=self.imageURL.split("/")[-1]
#lege neues images object an, mit leerem bild
if self.ZopeFind(self,obj_ids=[filename]):
#existiert das bild schon, dann neueun filenamen
filename="project_image_"+filename
self.addImage(None,self.imagecap,filename=filename)
#hole die bilddaten aus der url
data=urllib.urlopen(self.absolute_url()+"/"+self.imageURL).read()
obj=getattr(self,filename)
obj.update_data(data)
if RESPONSE:
RESPONSE.redirect('manageImages')
def manageImages(self,imageName=None,op=None):
"""managage images"""
if imageName and op:
if op=='up':
images=self.getImages()
for image in images:
if image[0]==imageName:
nr=images.index(image)
if not nr==0:
images[nr-1][1].place+=1
images[nr][1].place-=1
pass
elif op=='down':
images=self.getImages()
for image in images:
if image[0]==imageName:
nr=images.index(image)
if not (nr==len(images)-1):
images[nr+1][1].place-=1
images[nr][1].place+=1
pass
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.zpt')).__of__(self)
return pt()
def managePublications(self,pubName=None,op=None):
"""managage images"""
if pubName and op:
if op=='up':
publications=self.getPublications()
for publication in publications:
if publication[0]==pubName:
nr=publications.index(publication)
if not nr==0:
publications[nr-1][1].place+=1
publications[nr][1].place-=1
pass
elif op=='down':
publications=self.getPublications()
for publication in publications:
if publication[0]==pubName:
nr=publications.index(publication)
if not (nr==len(publications)-1):
publications[nr+1][1].place-=1
publications[nr][1].place+=1
pass
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
return pt()
def getPublications(self):
"""get all Publications"""
def sort_images(x,y):
return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
publications.sort(sort_images)
return publications
def addPublication(self,text,RESPONSE=None):
"""add an MPIWG_Publication"""
name="publication_"+str(self.getLastPublicationNumber()+1)
newPublication=MPIWGProject_publication(name)
self._setObject(name,newPublication)
obj=getattr(self,name)
obj.text=text[0:]
obj.enabled=True;
obj.place=self.getLastPublicationNumber()+1
obj.id=name
if RESPONSE is not None:
RESPONSE.redirect('managePublications')
def getLastPublicationNumber(self):
publications=self.getPublications()
if not publications:
return 0
else:
return getattr(publications[-1][1],'place',0)
def deletePublication(self,id,RESPONSE=None):
"""delete Publication id"""
self.manage_delObjects([id])
if RESPONSE:
RESPONSE.redirect('managePublications')
def getImages(self):
"""get all Images"""
def sort_images(x,y):
return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
images.sort(sort_images)
return images
def getLastImageNumber(self):
images=self.getImages()
if not images:
return 0
else:
return getattr(images[-1][1],'place',0)
def deleteImage(self,id,RESPONSE=None):
"""delete Image id"""
self.manage_delObjects([id])
if RESPONSE:
RESPONSE.redirect('manageImages')
def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
"""add an MPIWG_Project_image"""
if not filename:
filename=fileHd.filename
if not fileHd:
fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
newImage=MPIWGProject_image(filename,filename,fileHd)
self._setObject(filename,newImage)
obj=getattr(self,filename)
obj.caption=caption[0:]
obj.enabled=True;
obj.place=self.getLastImageNumber()+1
if RESPONSE is not None:
RESPONSE.redirect('manageImages')
def PrincipiaSearchSource(self):
"""Return cataloguable key for ourselves."""
return str(self)
def versionHeader(self):
"""version Header, gibt header text entsprechend der aktuellen version aus"""
actualTime=time.localtime()
retTXT="""<h2>This is an outdated version, for the actual version please refer to <a href="%s">%s</a></h2>"""
s=self.aq_parent.absolute_url()
#print getattr(self,'archiveTime',actualTime)
if getattr(self,'archiveTime',actualTime)< actualTime:
return retTXT%(s,s)
else:
return ""
def getActualVersion(self,date=None):
"""actuelle version"""
def sortProjectsByTime(x,y):
return cmp(x[1].archiveTime,y[1].archiveTime)
if not date:
if self.isActual():
return self
else:
return None
#suche ob aeltere versionen vorhanden sind
finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
ad=getattr(self,'creationTime','20050101000000')
if int(date)>int(ad):
return self
else:
return None
else:
finds.sort(sortProjectsByTime)
for find in finds:
#gehe durch die alten Projekte und finde das entprechende
if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
return find[1]
#kein passendes gefunden, dann teste ob das aktuelle in frage kommt
ad=getattr(self,'creationTime','20050101000000')
if int(date)>int(ad):
return self
else:
return None
def isActual(self):
"""gibt 1 zurueck wenn aktuell, 0 sonst"""
actualTime=time.localtime()
#print getattr(self,'archiveTime',actualTime)
if getattr(self,'archiveTime',actualTime)< actualTime:
return 0
else:
return 1
def copyObjectToArchive(self):
"""kopiere aktuelles objekt ins archiv"""
cb=self.aq_parent.manage_copyObjects(self.getId())
self.manage_pasteObjects(cb)
actualTime=time.localtime()
self.manage_renameObject(self.getId(),self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
obj=getattr(self,self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
obj.setArchiveTime(time.strftime("%Y%m%d%H%M%S",actualTime))
ids=[x[0] for x in self.ZopeFind(obj,obj_metatypes=['MPIWGProject'])]
obj.manage_delObjects(ids)
def setArchiveTime(self,time):
"""set Archive Time"""
self.archiveTime=time[0:]
def versionManageForm(self):
"""version Manage form:currently only set to invisible"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)
return pt()
def versionManage(self,invisible=None,RESPONSE=None):
"""version Manage form:currently only set to invisible"""
self.invisible=invisible
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def crossLinker(self):
"""experimental crosslinker"""
splitted=self.WEB_project_description[0].split()
new=[]
for split in splitted:
try:
found=self.DescriptionCatalog({'fulltext':split})
if len(found)>1:
new.append("<a href=%s>%s</a>"%(split,split))
else:
new.append(split)
except:
new.append(split)
return string.join(new)
def generateTemplate(self,RESPONSE=None):
"""Erzeuge Template für defined fields not_used"""
id="index_html"
title=id
if self._getOb('index_html'):
self._delObject('index_html')
newObj=ZopePageTemplate(id,'TEXT')
self._setObject(id,newObj)
#self.manage_addPageTemplate(id,title)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def __init__(self, id, argv=None):
"""initiere classe"""
self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]
self.id=id
self.title=id
if argv:
for arg in definedFields:
try:
setattr(self,arg,argv[arg])
except:
setattr(self,arg,"")
else:
for arg in definedFields:
setattr(self,arg,'')
manage_options = Folder.manage_options+(
{'label':'Load New File','action':'loadNewFileForm'},
{'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
{'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
{'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
{'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
{'label':'Versionmanager','action':'versionManageForm'},
)
def checkDate(self,date):
"""teste ob zum Zeitpunkt date eine andere version existierte"""
def sortProjectsByTime(x,y):
return cmp(x[1].archiveTime,y[1].archiveTime)
#suche ob aeltere versionen vorhanden sind
finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
ad=getattr(self,'creationTime','20050101000000')
if int(date)>int(ad):
return self.REQUEST['URL1']+"/"+self.getId()
else:
return self.REQUEST['URL1']+"/no_project"
else:
finds.sort(sortProjectsByTime)
for find in finds:
#gehe durch die alten Projekte und finde das entprechende
if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
return self.REQUEST['URL1']+"/"+find[1].getId()
#kein passendes gefunden, dann teste ob das aktuelle in frage kommt
ad=getattr(self,'creationTime','20050101000000')
if int(date)>int(ad):
return self.REQUEST['URL1']+"/"+self.getId()
else:
return self.REQUEST['URL1']+"/no_project"
def no_project(self):
"""warnung: project noch nicht existent"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)
return pt()
def index_html(self,request=True,context=None):
"""show homepage"""
if not context:
context=self
if request:
if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
self.REQUEST.SESSION['MPI_redirected']=1
self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date'])+"?date="+self.REQUEST['date'])
else:
self.REQUEST.SESSION['MPI_redirected']=None
#ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
ext=getattr(self,"project_main",None)
if ext:
return getattr(self,ext.getId())()
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)
return pt()
def getDataFields(self):
"""giveListofDatafields"""
ret=[]
for x in range(1,14):
if not x in [6,10,9]: # not used fields
ret.append('xdata_%02i'%x)
return ret
def getDefinedFields(self):
"""show all defined fields"""
return definedFields
def getAttribute(self,field):
"""get attrbiute"""
return getattr(self,field)
def getContent(self,field,filter=None):
"""Inhalt des Feldes"""
text=u''
for x in getattr(self,field):
try:
text +=x
except:
text = x
try:
if text[len(text)-1]==";":
text=text[0:len(text)-1]
except:
pass
if text=='':
text2=text
else:
text2=re.sub(r';([^\s])','; \g<1>',text)
#teste ob ergebnis leer und header dann nehme title
if (text2=='') and (field=='WEB_project_header'):
return self.getContent('WEB_title')
if filter:
splitted=text2.split("""<p class="picture">""")
if len(splitted)>1:
tmp=splitted[1].split("</p>")
#return repr(splitted[1])
try:
self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
except:
self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
split2="</p>".join(tmp[1:])
text3=splitted[0]+split2
splitted=text3.split("""<p class="picturetitle">""")
if len(splitted)>1:
tmp=splitted[1].split("</p>")
self.imagecap=tmp[0].encode('utf-8')
split4="".join(tmp[1:])
text5=splitted[0]+split4
else:
#keine caption
text5=text3
else:
#kein bild
text5=text2
else:
text5=text2
#teste ob WEB_project_description und keine führenden p tags
if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
text5= "<p>"+text5+"</p>"
#filter image
return text5.encode('utf-8')
def showImagesOfPage(self,imageUrl=None):
"""show Images of project"""
self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
return pt()
def show_html(self):
"""simple index"""
#return "HI"
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_index.zpt')).__of__(self)
return pt()
def saveFromPreview(self):
"""save content aus preview"""
self.WEB_project_description=self.previewTemplate.WEB_project_description[0:]
self.REQUEST.RESPONSE.redirect("./index.html")
def saveEditedContent(self,kupu=None,preview=None):
"""save Edited content"""
if preview:
kupu=preview
#find content of body tags
start=kupu.find("<body>")
end=kupu.find("</body>")
newcontent= kupu[start+6:end]
if preview:
return self.preview(newcontent)
self.copyObjectToArchive()
self.WEB_project_description=newcontent[0:]
self.REQUEST.RESPONSE.redirect("./index.html")
return True
security.declareProtected('View managment screens','edit')
def edit(self,western=None):
"""Edit pages"""
if western:
self.REQUEST.RESPONSE.setCookie("MP_debug_code","western",path="/")
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProjectNeu.zpt')).__of__(self)
return pt()
def preview(self,description):
"""preview"""
tmpPro=getattr(self,"previewTemplate",None)
if not tmpPro:
tmpPro=MPIWGProject("previewTemplate")
self._setObject("previewTemplate",tmpPro)
for field in definedFields:
setattr(tmpPro,field,getattr(self,field))
tmpPro.WEB_project_description=description[0:]
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','previewFrame.zpt')).__of__(self)
return pt()
#return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"/previewTemplate")
def getWebProject_description(self):
"""get description"""
debug= self.REQUEST.cookies.get("MP_debug_code",None)
if debug and debug=="western":
return """
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>%s
</html></body>
"""%self.WEB_project_description[0]
return """
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>%s
</html></body>
"""%self.getContent('WEB_project_description')
def editMPIWGProjectForm(self):
"""editform"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)
return pt()
def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
"""edit the project and archive the old version"""
self.copyObjectToArchive() # archive the object
for x in definedFields:
if self.REQUEST.has_key(x):
setattr(self,x,[self.REQUEST[x].decode('utf-8')])
if fromEdit and (RESPONSE is not None):
RESPONSE.redirect('./editMPIWGBasisEditor')
else:
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
security.declareProtected('View managment screens','editMPIWGDisciplinesThemesEditor')
def editMPIWGDisciplinesThemesEditor(self):
"""edit from edit"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemesNeu.zpt')).__of__(self)
return pt()
def editMPIWGDisciplinesThemesForm(self):
"""edit the disciplines and themes Form"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemes.zpt')).__of__(self)
return pt()
def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None,fromEdit=None):
"""edit disciplin and form"""
if disciplines:
if type(disciplines) is StringType:
self.xdata_09=disciplines
else:
self.xdata_09=string.join(disciplines,";")
else:
self.xdata_09=""
if themes:
if type(themes) is StringType:
self.xdata_10=themes
else:
self.xdata_10=string.join(themes,";")
else:
self.xdata_10=""
if fromEdit and (RESPONSE is not None):
RESPONSE.redirect('./editMPIWGDisciplinesThemesEditor')
else:
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def isChecked(self,wert,list):
"""check if wert is in ; seperated list"""
#felder sind manchmnal als liste mit einem element definiert
if type(list) is StringType or UnicodeType:
splitted=list.split(";")
else:
splitted=list[0].split(";")
splitted=[y.rstrip().lstrip() for y in splitted]
for x in splitted:
if (not x==u'') and x in wert:
return 1
return 0
security.declareProtected('View management screens','editMPIWGBasisEditor')
def editMPIWGBasisEditor(self):
"""editform"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)
return pt()
def editMPIWGBasisForm(self):
"""editform"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)
return pt()
def editMPIWGRelatedPublicationsForm(self):
"""Edit related Publications"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)
return pt()
def loadNewFileForm(self):
"""Neues XML-File einlesen"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_newfile.zpt')).__of__(self)
return pt()
def loadNewFile(self,RESPONSE=None):
"""einlesen des neuen files"""
fileupload=self.REQUEST['fileupload']
if fileupload:
file_name=fileupload.filename
filedata=fileupload.read()
argv=xmlhelper.proj2hash(filedata)
#print argv.keys()
for arg in definedFields:
#print arg,argv[arg],getattr(self,arg)
try:
temp=argv[arg][0:]
#old=getattr(self,arg)
setattr(self,arg,temp)
#print old,getattr(self,arg)
except:
"""nothing"""
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
def manage_addMPIWGProjectForm(self):
"""form for adding the project"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)
return pt()
def manage_addMPIWGProject(self,id,RESPONSE=None):
"""method to add a project"""
#print argv
fileupload=self.REQUEST.get('fileupload',None)
if fileupload:
file_name=fileupload.filename
filedata=fileupload.read()
argv=xmlhelper.proj2hash(filedata)
#print argv
newObj=MPIWGProject(id,argv)
else:
newObj=MPIWGProject(id)
self._setObject(id,newObj)
if RESPONSE is not None:
RESPONSE.redirect('manage_main')
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>