"""This contains the class MPIWG Projects
for organizing and maintaining the different project pages
$author dwinter - last change 26.06.2008
"""
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
from Products.ZCatalog.CatalogPathAwareness import CatalogAware
from Products.MPIWGBibliography.BibliographyManager import BibliographyManager
from OFS.Image import Image
from Globals import package_home
import urllib
import re
import os
from types import *
import logging
import xmlhelper # Methoden zur Verwaltung der projekt xml
from OFS.SimpleItem import SimpleItem
from OFS.Folder import Folder
from OFS.Image import Image
from AccessControl import ClassSecurityInfo
from bibliography import *
import time
#import xml.dom.minidom
import sys
#from Ft.Xml.XPath import Evaluate
#from Ft.Xml.XPath.Context import Context
#from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
#from Ft.Xml import EMPTY_NAMESPACE
#import copy
#import updatePersonalWWW
#import MPIWGStaff
from MPIWGHelper import *
import MPIWGRoot
import MPIWGLink
import MPIWGTemplate
# die folgenden Klassen sind jetzt in einzelne Files ausgelagert aus KompatibilitŠtsgrŸnden, bleiben die Klassen hier noch drin.
# Sonst funktionieren die alten Webseiten nicht mehr.
class MPIWGRoot(MPIWGRoot.MPIWGRoot):
"""depricated"""
class MPIWGLink(MPIWGLink.MPIWGLink):
"""depricated"""
class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
"""depricated"""
class MPIWGProject_publication(Folder):
"""publications object fuer project"""
meta_type="MPIWGProject_publication"
def editPublication(self,text=None,image1=None,image2=None,description=None,RESPONSE=None):
"""edit a publication"""
if (not text) and (not description):
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
return pt()
self.text=text[0:]
self.description=description
if image1:
if hasattr(self,'publicationImage1'):
self.publicationImage1.manage_upload(image1)
else:
nO = Image('publicationImage1','',image1)
self._setObject('publicationImage1',nO)
if image2:
if hasattr(self,'publicationImage2'):
self.publicationImage2.manage_upload(image2)
else:
nO = Image('publicationImage2','',image2)
self._setObject('publicationImage2',nO)
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 decode(self,str):
"""return unicode object"""
return unicodify(str)
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"""
#getImages from WEB_project_description
description=self.getContent('WEB_project_description')
text2=description
splitted=text2.split("""<p class="picture">""")
imageURLs=[]
imageCaptions=[]
for split in splitted[1:]:
tmp=split.split("</p>")
#return repr(splitted[1])
try:
imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
except:
try:
imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
except:
imageURLs.append("")
split2="</p>".join(tmp[1:])
splitted=split2.split("""<p class="picturetitle">""")
if len(splitted)>1:
tmp=splitted[1].split("</p>")
imageCaptions.append(tmp[0].encode('utf-8'))
else:
#keine caption
imageCaptions.append("")
#eintragen:
for imageURL in imageURLs:
filename=imageURL.split("/")[-1]
#lege neues images object an, mit leerem bild
if self.ZopeFind(self,obj_ids=[filename]):
#existiert das bild schon, dann neuen filenamen
filename="project_image_"+filename
self.addImage(None,imageCaptions[imageURLs.index(imageURL)],filename=filename)
#hole die bilddaten aus der url
url=self.absolute_url()+"/"+imageURL
#url=self.absolute_url()+"/"+filename
try:#relative url
data=urllib.urlopen(url).read()
except:
try:#absolute
data=urllib.urlopen(self.imageURL).read()
except:
logger("MPIWG Project",logging.ERROR,"can't open: %s"%url)
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 hasExtendedPublicationList(self):
"""test if extended publication list exists"""
if not hasattr(self,"publicationList"):
return False
else:
return True
def createExtendedPublicationList(self,RESPONSE=None):
"""erzeuge erweiterte publications liste"""
pl = BibliographyManager("publicationList","","institutsbiblio",self.connection_id)
self._setObject("publicationList", pl)
zt=ZopePageTemplate('index.html')
pl._setObject('index.html',zt)
default_content_fn = os.path.join(package_home(globals()),
'zpt/showExtendedProjectBibliography.zpt')
text = open(default_content_fn).read()
zt.pt_edit(text, 'text/html')
if RESPONSE:
RESPONSE.redirect("managePublications")
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))
if (getattr(self,'imageURL','')!='') or (getattr(self,'imagecap','')!='') :
try:
self.addImage(None,getattr(self,'imagecap',''),RESPONSE=None,filename=getattr(self,'imageURL',''))
except:
pass
self.imageURL=''
self.imagecap=''
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 hasChildren(self,date=None,onlyActive=1,onlyArchived=1):
"""check if project has children"""
ct=self.getContexts(childs=self.getContent('xdata_05'),
depth=1,date=date,onlyActive=onlyActive)
if ct and len(ct)>0:
return True
else:
return False
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
obj.id=filename
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 " ".join(new)
def generateTemplate(self,RESPONSE=None):
"""Erzeuge Template fuer 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
self.isActiveFlag=True #Flag is true is the project is still active, False if accomplished
self.responsibleScientistsList=[] # enthaelt die Lister der verantwortlichen Wissenschaftler in der Form (NAME, KEY), key ist "" flass Wissenschaftler nicht an unserem Haus
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 isActiveProject(self):
"""check if the project is still active, default is true, set to false is the project is accomplished"""
return getattr(self,'isActiveFlag',True)
def isArchivedProject(self):
"""check if the project is archived"""
completed=getattr(self,'completedAt',0)
#completed leer
if completed=="" :
return False;
if completed == 0:
return False;
return True
def setActiveFlag(self,status=True):
"""set the active flag"""
self.isActiveFlag=status
def setCompletedAt(self,date):
"""set the date of completion, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
logging.info("DATE:"+repr(date))
transformedDate=self.transformDate(date);
logging.info("transformed"+repr(transformedDate))
if transformedDate is not None:
setattr(self,"completedAt",transformedDate)
return True;
else:
return False;
def setStartedAt(self,date):
"""set the date of start, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
logging.info("DATE:"+repr(date))
transformedDate=self.transformDate(date);
logging.info("transformed"+repr(transformedDate))
if transformedDate is not None:
setattr(self,"startedAt",transformedDate)
return True;
else:
return False;
def getCompletedAt(self):
"""gibt das transformierte Datum zurueck, an dem das Projekt beendet wurde."""
date=getattr(self,'completedAt','')
if date:
return self.reTransformDate(date);
else:
return '';
def getStartedAt(self):
"""gibt das transformierte Datum zurŸck, an dem Projekt begonnen wurde."""
date=getattr(self,'startedAt','')
if date:
return self.reTransformDate(date);
else:
return '';
def reTransformDate(self,date):
"""transformiert , transformdate zurueck"""
year=int(date/10000)
month=int((date-year*10000)/100)
day=int((date-year*10000-month*100))
if (day==0) and (month==0):
return """%s"""%year;
if day==0 :
return """%s.%s"""%(month,year);
return """%s.%s.%s"""%(day,month,year);
def transformDate(self,date):
"""transformiert ein Datum von DD.MM.YYYY, MM.YYYY,YYYY nach YYYYMMDD, alle nicht angebebenn Werte
werden auf 0 gesetzt, es wird null zurŸckgegeben falls das Datum ungueltig ist"""
if (date==None):
return None;
if (date.lstrip().rstrip()=="" ) :
return "";
splitted=date.split(".")
length=len(splitted)
year=0
month=0
day=0
if length > 3:
return "";
if length==3:
day = int(splitted[0])
if length>1:
month=int(splitted[length-2])
if length > 0:
try:
year = int(splitted[length-1])
except:
pass
## logging.info("month:"+(month))
if not (0<=month<13):
return None;
if not(0<=day<32):
return None;
if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
year=2000+year;
return year*10000+month*100+day
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 getGetNeighbourhood(self,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
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=self.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 harvest_page(self,context=None):
"""seite fuer harvesting fuer die Projektsuche"""
if not context:
context=self
if self.isActiveProject() and self.isActual():
ext=getattr(self,"harvest_main",None)
if ext:
return getattr(self,ext.getId())()
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)
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:
try:
self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
except:
self.imageURL=""
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 fuehrenden p tags
if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
text5= "<p>"+text5+"</p>"
#filter image
text5=text5.lstrip().rstrip() #loescher leerzeichen und einzelndes br
if (text5=="<br>") or (text5=="<br/>"):
text5=""
logging.debug("getcontent: field=%s filter=%s -> %s"%(field,filter,repr(text5)))
return unicodify(text5)
#return utf8ify(text5) # return as utf-8 byte string
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 management 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()
edit_MPIWGProject_main = PageTemplateFile('zpt/edit_MPIWGProject_main', globals())
def getPathStyle(self, path, selected, style=""):
"""returns a string with the given style + 'sel' if path == selected."""
if path == selected:
return style + 'sel'
else:
return style
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:]
tmpPro.invisible=True
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 isResponsibleScientist(self,key):
"""teste ob eine Person in der Liste der respl. scientists auftaucht"""
#logging.info("XXXXXXXXXXXXX"+repr(self.responsibleScientistsList))
keys = [x[1] for x in getattr(self,"responsibleScientistsList",[])]
if key in keys:
return True
else:
return False
def getPersonKeyList(self):
"""gibt die key Lister der beteiligten Personen zurŸck"""
return [x[1] for x in getattr(self,'responsibleScientistsList',[])]
def identifyNames(self,nameList):
"""Bekommt eine Komma oder Semikolon getrennte Liste mit Name der Form Vorname MittelName(n) Nachname
und ordnet diese dann Mitarbeiter IDs zu falls es schone eine Liste gibt wird im Projekte gibt wird diese Upgedated.
@param nameList
"""
nameList=nameList.replace(";",",") # falls ; als Trenner ersetze
names=nameList.split(",")
returnNamesDict={}
for name in names:
name=name.lstrip().rstrip()
nameSplitted = name.split(" ")
if len(nameSplitted)>1: #vor und nachname angegeben)
lastname=nameSplitted[-1]
firstname=nameSplitted[0]
else:
firstname =""
lastname=nameSplitted[0]
#finde Mitarbeiter mit den entsprechenden Name
logging.info("Search: %s %s %s"%(name,firstname,lastname))
firstname=firstname.capitalize()
lastname=lastname.capitalize()
try:
cataloggedNames=self.MembersCatalog(firstName=firstname,lastName=lastname)
except:
cataloggedNames=[]
#Teste ob die ensprechenden Namen schon der Liste zu geordnet sind
#if not hasattr(self,'responsibleScientistsList'):
# self.responsibleScientistsList={}
#
# if name in self.responsibleScientistsList.values()
if len(cataloggedNames)>0:
returnNamesDict[name]=cataloggedNames
else:
returnNamesDict[name]=[]
return returnNamesDict
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')])
completedAt = self.REQUEST.get('completedAt')
if not self.setCompletedAt(completedAt):
RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
startedAt = self.REQUEST.get('startedAt')
if not self.setStartedAt(startedAt):
RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
if self.REQUEST.has_key('historicalNames'):
self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))
if self.REQUEST.has_key('active'):
self.setActiveFlag(True)
else:
self.setActiveFlag(False)
self.responsibleScientistsList=[] # setze die Liste der verantwortlichen Wissenschaftler zurueck
names={}
keys={}
tmpList=[]
for key in self.REQUEST.keys(): #gehe durch das Formular
splitted=key.split("_")
if splitted[0]=="responsibleScientist": #wenn es ein Feld der Form reponsibleScientist_nr_KEY gibt
nr=splitted[2]
if splitted[1]=="name":
names[nr]=self.REQUEST[key]
elif splitted[1]=="key":
keys[nr]=self.REQUEST[key]
for nr in names.keys():
tmpList.append((names[nr],keys.get(nr,"")))
self.responsibleScientistsList=tmpList
if fromEdit and (RESPONSE is not None):
#RESPONSE.redirect('./editMPIWGBasisEditor')
return self.editMPIWGBasisEditor(identifiedNames=self.identifyNames(self.REQUEST.get('xdata_01','')))
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=";".join(disciplines)
else:
self.xdata_09=""
if themes:
if type(themes) is StringType:
self.xdata_10=themes
else:
self.xdata_10=";".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:
x=re.sub(r"[^A-z ]","",x)
if (not x==u'') and x in wert:
return 1
return 0
security.declareProtected('View management screens','editMPIWGBasisEditor')
def editMPIWGBasisEditor(self, identifiedNames=None):
"""editform"""
if not identifiedNames:
identifiedNames=self.identifyNames(self.getContent('xdata_01'))
# identifiedNames=self.getFullNameEntries()
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)
return pt(identifiedNames=identifiedNames)
security.declareProtected('View management screens','editMPIWGBasisForm')
def editMPIWGBasisForm(self):
"""editform"""
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)
return pt()
security.declareProtected('View management screens','editMPIWGRelatedPublicationsForm')
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>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to MPIWGProjects.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / MPIWGWeb