[BACK]Return to MPIWGProjects.py CVS log [TXT] [DIR] Up to [Repository] / MPIWGWeb

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.47.2.23 and 1.47.2.123

version 1.47.2.23, 2005/09/15 12:57:41 version 1.47.2.123, 2012/01/06 08:23:10
Line 1 Line 1
 """This contains the class MPIWG Projects  """This contains the class MPIWG Projects
 for organizing and maintaining the different project pages  for organizing and maintaining the different project pages
   
   $author dwinter   - last change  26.06.2008
   
 """  """
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder  
 from Products.ZCatalog.CatalogPathAwareness import CatalogAware  from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from Products.MPIWGBibliography.BibliographyManager import BibliographyManager
 from OFS.Image import Image  from OFS.Image import Image
 from Globals import package_home  from Globals import package_home
 import urllib  import urllib
 import MPIWGStaff  
 import string  
 import re  import re
 import os  import os
   import email
 from types import *  from types import *
 import zLOG  import logging
 import xmlhelper # Methoden zur Verwaltung der projekt xml  import xmlhelper # Methoden zur Verwaltung der projekt xml
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from Products.ZSQLMethods.SQL import SQLConnectionIDs  from OFS.Image import Image
 from AccessControl import ClassSecurityInfo  from AccessControl import ClassSecurityInfo
   from AccessControl import getSecurityManager
 from bibliography import *  from bibliography import *
 import time  import time
   from OFS.Cache import Cacheable
   import xmlrpclib
   #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 Kompatibilitaetsgruenden, bleiben die Klassen hier noch drin.
   # Sonst funktionieren die alten Webseiten nicht mehr.
   
   class MPIWGRoot(MPIWGRoot.MPIWGRoot):
       """depricated"""
   
 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']  class MPIWGLink(MPIWGLink.MPIWGLink):
       """depricated"""
 checkFields = ['xdata_01']  
   
   
   
 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):  class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
     """create a symbolic link to another page"""      """depricated"""
   
     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):  class MPIWGProject_publication(Folder):
         """index"""      """publications object fuer project"""
           
         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      meta_type="MPIWGProject_publication"
       def redirect(self,RESPONSE,url):
           """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
   
           timeStamp=time.time()
   
 def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):          if url.find("?")>-1: #giebt es schon parameter
     "Add a Page Template with optional file content."              addStr="&time=%s"
     if type(MPIWGType)==StringType:  
         MPIWGTypes=[MPIWGType]  
     else:      else:
         MPIWGTypes=MPIWGType              addStr="?time=%s"
                   
     for singleType in MPIWGTypes:          RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
           logging.debug(email.Utils.formatdate()+' GMT')
           RESPONSE.redirect(url+addStr%timeStamp)
   
       def hasLinkToBookPage(self):
           """teste ob eingebener link zu einer MPIWG Book page geht"""
   
         if REQUEST is None:          if (getattr(self,'link','')==''):
             self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))              return False #es gibt keinen link
             ob = getattr(self, id)  
                           
             if title:          server = xmlrpclib.ServerProxy(self.link)
                 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:              try:
                 u = self.DestinationURL()              server.getImageUrls()
             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 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                  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:          except:
               return False
             """nothing"""  
         field=re.sub(r';([^\s])','; \g<1>',field)  
         return field.encode('utf-8')  
   
   
       def getImageUrls(self):
           """get the image urls"""
           
     def sortedNames(self,list):          if (getattr(self,'link','')==''):
         """sort names"""              return False #es gibt keinen link
   
         def sortLastName(x_c,y_c):          server = xmlrpclib.ServerProxy(self.link)
             try:  
                 x=urllib.unquote(x_c).encode('utf-8','ignore')  
             except:  
                 x=urllib.unquote(x_c)  
   
             try:              try:
                 y=urllib.unquote(y_c).encode('utf-8','ignore')              urls = server.getImageUrls()
             except:              ret=[]
                 x=urllib.unquote(y_c)              for url in urls:
                                   url = os.path.join(self.link,url)
                   ret.append(url)
               
             try:  
                 last_x=x.split()[len(x.split())-1]  
                 last_y=y.split()[len(y.split())-1]  
   
             except:              except:
               return []
   
                 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              return ret
                   
         list={}      def editPublication(self,text=None,image1=None,image2=None,description=None,link=None,RESPONSE=None):
         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])          """edit a publication"""
                   
         for project in projects:          if (not text) and (not description):
             lg=len(project[1].xdata_03[0])-1              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
               return pt()
   
             if (lg>1) and (project[1].xdata_03[0][lg]==";"):  
                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]  
   
           if text:
               self.text=text[0:]
                       
           if description:
               self.description=description
             
           if link:
               self.link=link[0:]
                                   
             try:          if image1:
                 if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;              if hasattr(self,'publicationImage1'):
                     for person in project[1].xdata_03[0].split(";"):                  self.publicationImage1.manage_upload(image1)
                         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:                          else:
                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])                  nO = Image('publicationImage1','',image1)
                   self._setObject('publicationImage1',nO)
             except:  
                 zLOG.LOG("MPIWG Web (harvestHistoricalPerson)",zLOG.ERROR,"cannot annalyize: %s"%repr(project))  
   
                   
         return list  
   
     def storeHistoricalPersons(self,RESPONSE=None):          if image2:
         """store persons"""              if hasattr(self,'publicationImage2'):
         self.personDict={}                  self.publicationImage2.manage_upload(image2)
         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:                  else:
                     self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])                  nO = Image('publicationImage2','',image2)
                   self._setObject('publicationImage2',nO)
   
         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')  
                   
           self.ZCacheable_invalidate()
           if RESPONSE:
               self.redirect(RESPONSE,"../managePublications")
   
     def showHistoricalPersons(self):  class MPIWGProject_relatedProject(Folder):
         """show persons"""      """publications object fuer project"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showHistoricalPersons')).__of__(self)  
         return pt()  
   
                   
     def editHistoricalPersonsForm(self):      meta_type="MPIWGProject_relatedProject"
         """edit historical persons for consistency"""      def redirect(self,RESPONSE,url):
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalPersonsForm')).__of__(self)          """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
         return pt()  
   
     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry, date=None):          timeStamp=time.time()
         """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:          if url.find("?")>-1: #giebt es schon parameter
             fieldContentsTmp=[fieldContentsEntry]              addStr="&time=%s"
         else:          else:
             fieldContentsTmp=fieldContentsEntry              addStr="?time=%s"
   
         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)          RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
         return ret          logging.debug(email.Utils.formatdate()+' GMT')
           RESPONSE.redirect(url+addStr%timeStamp)
     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:      def editRelatedProject(self,link=None,RESPONSE=None):
             RESPONSE.redirect('manage_main')          """edit a publication"""
   
     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:          if (not link):
             splitted=parents.split(".")              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_relatedProjectForm.zpt')).__of__(self)
             parentId=string.join(splitted[0:len(splitted)-1],".")              return pt()
                   
             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)          # hole die id des projektes
                     else:          splitted=link.split("/")
                         ret.append(project)  
         return ret  
           
     def getProjectFields(self,fieldName,date=None,folder=None,sort=None):          #teste ob es das project gibt
         """getListofFieldNames"""          if len(splitted)<1:
         ret=[]              self.redirect(RESPONSE,'errorRelatedProjects?link='+link)
           
         objects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'],search_sub=0)          objid=splitted[-1]
           object = getattr(self.projects,objid,None)
   
           if object==None:
               self.redirect(RESPONSE,'errorRelatedProjects?link='+link)
                                   
         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":          self.orginallink=link[0:]
             ret.sort(sortI)          self.objid=objid[0:]
         else:  
             ret.sort(sortF)  
                   
         return ret          self.projectWEB_title=object.getContent('WEB_title')[0:]
   
     def showNewProjects(self):          self.enabled=True;
         projects=[]          self.ZCacheable_invalidate()
         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)          if RESPONSE:
                               self.redirect(RESPONSE,"../manageRelatedProjects")
         return projects  
           
   class MPIWGProject_image(Image):
       """Images for Projects"""
                   
     manage_options = Folder.manage_options+(      meta_type="MPIWGProject_image"
         {'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):      def showImage(self,imageUrl=None):
         """Form"""          """show Images at an extra page"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGNamesForm.zpt')).__of__(self)          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()          return pt()
   
     def importNames(self,fileupload,folderName,RESPONSE=None):      def editImage(self,file=None,caption=None,RESPONSE=None):
         """import komma-sep list email,lastName,firstName"""          """edit the Image"""
         project=getattr(self,folderName)          if (not file) and (not caption):
         load=fileupload.read()              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
                       return pt()
         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 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'])  
       
                       
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
           if file and (not file.filename.lstrip().rstrip()==""):
               self.manage_upload(file)
                   
     def getAllMembers(self):          if caption:
         """give list of all members"""              self.caption=caption[0:]
         ret=[]  
   
         #for x in self.members.objectValues('MPIWGStaff'):          if RESPONSE:
             #print x.title              self.redirect(RESPONSE,"../manageImages")
         #    ret.append(x.title.decode('utf-8'))  
   
         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):  class MPIWGProject(CatalogAware,Folder,Cacheable):
                                ret.append(x[1].title.decode('utf-8'))      """Class for Projects"""
                           
         ret.sort()      def _p_resolveConflict(self, oldState, savedState, newState):
         #print ret          return newState
       
         return ret      security=ClassSecurityInfo()
       meta_type='MPIWGProject'
       default_catalog='ProjectCatalog'
   
     def printAllMembers(self):      def redirect(self,RESPONSE,url):
         """prin"""          """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
         members=self.getAllMembers()  
         ret=""  
         for x in members:  
             ret+="<p>%s</p>"%x  
         return ret  
           
           timeStamp=time.time()
                   
     def makeList(self,entry):          if url.find("?")>-1: #giebt es schon parameter
         """makes a list out of one entry or repeat a list"""              addStr="&time=%s"
         if type(entry) is StringType:  
             return [entry]  
         else:          else:
             return entry              addStr="?time=%s"
   
           RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
           logging.debug(email.Utils.formatdate()+' GMT')
           RESPONSE.redirect(url+addStr%timeStamp)
   
     def getTree(self,date=None):      def decode(self,str):
         """generate Tree from project list"""          """return unicode object"""
           return unicodify(str)
   
         returnList=[]      def sortedByPlace(self,metatype):
         for project in self.getProjectFields('xdata_05',sort="int",date=date): # get Projects sorted by xdata_05          """find metatype and sort by place"""
           def sort(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
             for idNr in project[1].split(";"): # more than one number          founds=self.ZopeFind(self,obj_metatypes=[metatype]);
                 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          founds.sort(sort)
   
     def formatElementsAsList(self,elements):          return founds
         """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]      def copyPublicationsToList(self,RESPONSE=None):
           """copy publications in to list"""
                                   
             elif (element[0]<actualDepth):          publicationTxt=self.getContent('WEB_related_pub')
                 #fuege soviele /ul ein wie unterschied in tiefe  
                 for i in range(-element[0]+actualDepth):  
   
                     ret+="<br><br></li></ul>\n"          pubSplits=publicationTxt.split("<p>")
   
                     #ret+="<br><br>\n</li>\n</ul>\n</li>\n"          for pubSplit in pubSplits:
               pubSplit=pubSplit.replace("</p>","")
               self.addPublication(pubSplit)
   
           setattr(self,"WEB_related_pub_copied",True);
   
                 if element[0]==1:          if RESPONSE:
                     department=int(element[3].getContent('xdata_05'))-1  
                                           
                     ret+="""</ul></div>\n"""              self.redirect(RESPONSE,'managePublications')
             if department==4: #hack  
             department=3  
   
                     ret+="""<div class="bildspalte"><img src="../grafik/dept%i.jpg" width="160" height="120" vspace="40"></div>      def hasRelatedPublicationsOldVersion(self):
                     <div class="dept">\n<ul class="liste">\n          """teste ob es related publications gibt"""
                     """%department  
                           
                 actualDepth=element[0]          ret = True;
             else:          if (self.getContent('WEB_related_pub')==''):
                 ret+="""\n</li>\n"""              ret=False;  #nichts im alten feld
             ret+="""<li>\n"""          logging.debug("webrel:"+repr(ret))
           if (getattr(self,'WEB_related_pub_copied',False)):
               ret=False; # alte daten sind schon kopiert worden
                           
             if actualDepth==1:          logging.debug("webrel_copied:"+repr(ret))
                 departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'Ind. Research Group','5':'Ind. Research Group'}           publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication']);
                 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'):          if(len(publications)>0):
                 ret+="""<a href="%s?date=%s">%s</a>"""%(self.generateUrlProject(element[3].absolute_url())+"/index.html",self.REQUEST['date'],element[3].getContent('WEB_title'))              ret=False; # es gibt publicationen in der neuen liste
             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:          logging.debug("len(publ)"+repr(ret))
             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)  
   
           return ret;
   
         if RESPONSE is not None:      def hasRelatedDigitalSources(self):
             RESPONSE.redirect('showTree')          """test ob es digital sources gibt"""
                   
     def changeTree(self,RESPONSE=None):  
         """change the complete tree"""  
         form=self.REQUEST.form  
         hashList={}  
         fields=self.getTree()  
   
           ret = (self.getContent('xdata_11').lstrip().rstrip()=='')
                   
         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:          return not ret;
             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 copyImageToMargin(self,RESPONSE=None):  
           """copy inline images to marginal images"""
                           
                   
     def getRelativeUrlFromPerson(self,list):          #getImages from WEB_project_description
         """get urls to person list"""          description=self.getContent('WEB_project_description')
         ret=[]  
         persons=list.split(";")  
         for person in persons:  
                           
             if len(person)>1: #nicht nur Trennzeichen          text2=description
                 splitted=person.split(",")          splitted=text2.split("""<p class="picture">""")
                 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=='':          imageURLs=[]
           imageCaptions=[]
           for split in  splitted[1:]:
                   tmp=split.split("</p>")
                   #return repr(splitted[1])
   
                     try:                      try:
                         proj=self.MembersCatalog({'title':search})                          imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
                     except:                      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:                      try:
                         proj=self.MembersCatalog({'title':search})                          imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
                     except:                      except:
                         proj=None                          imageURLs.append("")
   
                 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):                  split2="</p>".join(tmp[1:])
         """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):                  splitted=split2.split("""<p class="picturetitle">""")
         """check if person is in personfolder and return list of person objects"""                  if len(splitted)>1:
                       tmp=splitted[1].split("</p>")
                       imageCaptions.append(tmp[0].encode('utf-8'))
                   
         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:          else:
             return []                      #keine caption
               
 ##         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')  
                   
                       imageCaptions.append("")
           
     def copyImageToMargin(self,RESPONSE=None):  
         """copy inline images to marginal images"""  
         self.getContent('WEB_project_description',filter='yes')  
   
         filename=self.imageURL.split("/")[-1]          #eintragen:
           for imageURL in imageURLs:
               filename=imageURL.split("/")[-1]
         #lege neues images object an, mit leerem bild          #lege neues images object an, mit leerem bild
   
         if self.ZopeFind(self,obj_ids=[filename]):          if self.ZopeFind(self,obj_ids=[filename]):
             #existiert das bild schon, dann neueun filenamen                  #existiert das bild schon, dann neuen filenamen
             filename="project_image_"+filename              filename="project_image_"+filename
                           
         self.addImage(None,self.imagecap,filename=filename)              self.addImage(None,imageCaptions[imageURLs.index(imageURL)],filename=filename)
         #hole die bilddaten aus der url          #hole die bilddaten aus der url
         data=urllib.urlopen(self.absolute_url()+"/"+self.imageURL).read()              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=getattr(self,filename)
         obj.update_data(data)          obj.update_data(data)
                   
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect('manageImages')          
               self.redirect(RESPONSE,'manageImages')
                           
     def manageImages(self,imageName=None,op=None):      def manageImages(self,imageName=None,op=None):
         """managage images"""          """managage images"""
Line 1294  class MPIWGProject(CatalogAware,Folder): Line 444  class MPIWGProject(CatalogAware,Folder):
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
         return pt()          return pt()
   
       def manageRelatedProjects(self,pubName=None,op=None):
           """managage relatedProjectd"""
   
   
           if pubName and op:
               if op=='up':
                   relatedProjects=self.getRelatedProjects()
                   for project in relatedProjects:
                       if project[0]==pubName:
                           nr=relatedProjects.index(project)
                           if not nr==0:
                               relatedProjects[nr-1][1].place+=1
                               relatedProjects[nr][1].place-=1
                           pass
               elif op=='down':
                   relatedProjects=self.getRelatedProjects()
                   for project in relatedProjects:
                       if project[0]==pubName:
                           nr=relatedProjects.index(project)
                           if not (nr==len(relatedProjects)-1):
                               relatedProjects[nr+1][1].place-=1
                               relatedProjects[nr][1].place+=1
                           pass
   
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageRelatedProjectsForm.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:
               self.redirect(RESPONSE,"managePublications")
   
               
     def getPublications(self):      def getPublications(self):
         """get all Publications"""          """get all Publications"""
         def sort_images(x,y):          def sort_images(x,y):
             return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
         print self.getId()  
         publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])          publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
                   
         publications.sort(sort_images)          publications.sort(sort_images)
         return publications          return publications
   
       def getRelatedProjects(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_relatedProject'])
           
           publications.sort(sort_images)
           return publications
   
     def addPublication(self,text,RESPONSE=None):      def addPublication(self,text,RESPONSE=None):
         """add an MPIWG_Publication"""          """add an MPIWG_Publication"""
           number=self.getLastPublicationNumber()+1
         name="publication_"+str(self.getLastPublicationNumber()+1)          name="publication_"+str(number)
           while hasattr(self,name):
               number+=1
               name="publication_"+str(number)
                   
         newPublication=MPIWGProject_publication(name)          newPublication=MPIWGProject_publication(name)
   
Line 1317  class MPIWGProject(CatalogAware,Folder): Line 534  class MPIWGProject(CatalogAware,Folder):
         obj.enabled=True;          obj.enabled=True;
         obj.place=self.getLastPublicationNumber()+1          obj.place=self.getLastPublicationNumber()+1
         obj.id=name          obj.id=name
           self.ZCacheable_invalidate()
           if RESPONSE is not None:
           
               self.redirect(RESPONSE,'managePublications')
   
       def errorRelatedProjects(self,link):
           """error creating a related project"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_project_error_relatedProject.zpt')).__of__(self)
           return pt(link=link)
   
       def addRelatedProject(self,link,RESPONSE=None):
           """add an MPIWG_Publication"""
                   
           
           
           number=self.getLastPublicationNumber()+1
           name="RelatedProject"+str(number)
           while hasattr(self,name):
               number+=1
               name="RelatedProject_"+str(number)
           
           # hole die id des projektes
           splitted=link.split("/")
           
           #teste ob es das project gibt
           if len(splitted)<1:
               self.redirect(RESPONSE,'errorRelatedProjects?link='+link)
           
           objid=splitted[-1]
           object = getattr(self.projects,objid,None)
           
           if object==None:
               self.redirect(RESPONSE,'errorRelatedProjects?link='+link)
               return
           
           newPublication=MPIWGProject_relatedProject(name)
   
           self._setObject(name,newPublication)
           obj=getattr(self,name)
           obj.orginallink=link[0:]
           obj.objid=objid[0:]
           logging.debug("add relobj:objid"+repr(obj.objid))
           obj.projectWEB_title=object.getContent('WEB_title')[0:]
           logging.debug("add relobj:webtitle"+repr(obj.projectWEB_title))
           obj.enabled=True;
           obj.place=self.getLastRelatedProjectNumber()+1
           obj.id=name
           self.ZCacheable_invalidate()
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('managePublications')          
               self.redirect(RESPONSE,'manageRelatedProjects')
   
   
     
     def getLastPublicationNumber(self):      def getLastPublicationNumber(self):
Line 1330  class MPIWGProject(CatalogAware,Folder): Line 596  class MPIWGProject(CatalogAware,Folder):
         else:          else:
             return getattr(publications[-1][1],'place',0)              return getattr(publications[-1][1],'place',0)
                   
       def getLastRelatedProjectNumber(self):
           publications=self.getRelatedProjects()
           
           if not publications:
               return 0
           else:
               return getattr(publications[-1][1],'place',0)
           
     def deletePublication(self,id,RESPONSE=None):      def deletePublication(self,id,RESPONSE=None):
         """delete Publication id"""          """delete Publication id"""
         self.manage_delObjects([id])          self.manage_delObjects([id])
               self.ZCacheable_invalidate()
               if RESPONSE:
           
                   self.redirect(RESPONSE,'managePublications')
                 
       def deleteRelatedProject(self,id,RESPONSE=None):
               """delete Publication id"""
               self.manage_delObjects([id])
               self.ZCacheable_invalidate()
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect('managePublications')          
                   self.redirect(RESPONSE,'manageRelatedProjects')
   
     def getImages(self):      def getImages(self):
         """get all Images"""          """get all Images"""
   
         def sort_images(x,y):          def sort_images(x,y):
             return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
         print self.getId()  
   
           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=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
                   
         images.sort(sort_images)          images.sort(sort_images)
Line 1356  class MPIWGProject(CatalogAware,Folder): Line 650  class MPIWGProject(CatalogAware,Folder):
                   
     def deleteImage(self,id,RESPONSE=None):      def deleteImage(self,id,RESPONSE=None):
         """delete Image id"""          """delete Image id"""
           try:
         self.manage_delObjects([id])          self.manage_delObjects([id])
           except:
                   logging.error("ERROR MPIWG: %s %s"%sys.exc_info()[0:2])
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect('manageImages')              self.redirect(RESPONSE,'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):      def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
         """add an MPIWG_Project_image"""          """add an MPIWG_Project_image"""
Line 1376  class MPIWGProject(CatalogAware,Folder): Line 687  class MPIWGProject(CatalogAware,Folder):
         obj.caption=caption[0:]          obj.caption=caption[0:]
         obj.enabled=True;          obj.enabled=True;
         obj.place=self.getLastImageNumber()+1          obj.place=self.getLastImageNumber()+1
           obj.id=filename
                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manageImages')              
               self.redirect(RESPONSE,'manageImages')
   
     def PrincipiaSearchSource(self):      def PrincipiaSearchSource(self):
         """Return cataloguable key for ourselves."""          """Return cataloguable key for ourselves."""
Line 1447  class MPIWGProject(CatalogAware,Folder): Line 760  class MPIWGProject(CatalogAware,Folder):
         else:          else:
             return 1              return 1
                   
       def isActualForIndex(self): #isActual kann nicht indiziert werden, da intern fom ZCAtalog verwendete Funktion
           """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):      def copyObjectToArchive(self):
         """kopiere aktuelles objekt ins archiv"""          """kopiere aktuelles objekt ins archiv"""
           logging.info("copytoarchive 1")
         cb=self.aq_parent.manage_copyObjects(self.getId())          cb=self.aq_parent.manage_copyObjects(self.getId())
           logging.info("copytoarchive 2")
         self.manage_pasteObjects(cb)          self.manage_pasteObjects(cb)
           logging.info("copytoarchive 3")
         actualTime=time.localtime()          actualTime=time.localtime()
                   
         self.manage_renameObject(self.getId(),self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))          self.manage_renameObject(self.getId(),self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
           logging.info("copytoarchive 4")
         obj=getattr(self,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))          obj.setArchiveTime(time.strftime("%Y%m%d%H%M%S",actualTime))
           logging.info("copytoarchive 5")
         ids=[x[0] for x in self.ZopeFind(obj,obj_metatypes=['MPIWGProject'])]          ids=[x[0] for x in self.ZopeFind(obj,obj_metatypes=['MPIWGProject'])]
           logging.info("copytoarchive 6")
         obj.manage_delObjects(ids)          obj.manage_delObjects(ids)
           logging.info("copytoarchive 7")
                   
     def setArchiveTime(self,time):      def setArchiveTime(self,time):
         """set Archive Time"""          """set Archive Time"""
         self.archiveTime=time[0:]          self.archiveTime=time[0:]
                   
       def delArchiveTime(self):
           """delete archive time"""
           del self.archiveTime
   
     def versionManageForm(self):      def versionManageForm(self):
         """version Manage form:currently only set to invisible"""          """version Manage form:currently only set to invisible"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)
Line 1473  class MPIWGProject(CatalogAware,Folder): Line 808  class MPIWGProject(CatalogAware,Folder):
         self.invisible=invisible          self.invisible=invisible
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              
               self.redirect(RESPONSE,'manage_main')
   
         
     def crossLinker(self):      def crossLinker(self):
Line 1491  class MPIWGProject(CatalogAware,Folder): Line 827  class MPIWGProject(CatalogAware,Folder):
                     new.append(split)                      new.append(split)
             except:              except:
                 new.append(split)                  new.append(split)
         return string.join(new)          return " ".join(new)
                           
                           
   
   
     def generateTemplate(self,RESPONSE=None):      def generateTemplate(self,RESPONSE=None):
         """Erzeuge Template für defined fields not_used"""          """Erzeuge Template fuer defined fields not_used"""
   
         id="index_html"          id="index_html"
         title=id          title=id
Line 1509  class MPIWGProject(CatalogAware,Folder): Line 845  class MPIWGProject(CatalogAware,Folder):
         self._setObject(id,newObj)          self._setObject(id,newObj)
         #self.manage_addPageTemplate(id,title)          #self.manage_addPageTemplate(id,title)
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              self.redirect(RESPONSE,'manage_main')
                           
     def __init__(self, id, argv=None):      def __init__(self, id, argv=None):
         """initiere classe"""          """initiere classe"""
Line 1517  class MPIWGProject(CatalogAware,Folder): Line 853  class MPIWGProject(CatalogAware,Folder):
         self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]          self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]
         self.id=id          self.id=id
         self.title=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:          if argv:
             for arg in definedFields:              for arg in definedFields:
         try:          try:
Line 1537  class MPIWGProject(CatalogAware,Folder): Line 876  class MPIWGProject(CatalogAware,Folder):
         )          )
   
   
       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=self.getCompletedAt()
          
          #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 ""
               # test ob parent abgeschlossen ist
               try:          #TODO: ersetzte try except durch vernuenftige abfrage  
                   ct=self.getContexts(parents=self.getContent('xdata_05'),depth=1)
                   if (len(ct)>0): #is there are parent
                           return ct[0][0].getCompletedAt()
                   return '';
               except:
                   return '';
           
       def getStartedAt(self):
           """gibt das transformierte Datum zurueck, 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 angebenen Werte
           werden auf 0 gesetzt, es wird null zurueckgegeben 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):      def checkDate(self,date):
         """teste ob zum Zeitpunkt date eine andere version existierte"""          """teste ob zum Zeitpunkt date eine andere version existierte"""
                   
Line 1578  class MPIWGProject(CatalogAware,Folder): Line 1042  class MPIWGProject(CatalogAware,Folder):
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)
         return pt()          return pt()
           
     
       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):      def index_html(self,request=True,context=None):
         """show homepage"""          """show homepage"""
       
           bound_names={}
            
           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"])
         
      
           request2=getattr(self,'REQUEST',None)
           
           if request2 is not None:
               response = request2.response
               if not response.headers.has_key('content-type'):
                   response.setHeader('content-type', 'text/html')
   
           security = getSecurityManager()
           bound_names['user'] = security.getUser()
         
           # Retrieve the value from the cache.
           keyset = None
           if self.ZCacheable_isCachingEnabled():
               
               # Prepare a cache key.
               keyset = {'here': self, 'params':request2['QUERY_STRING']}
                         
               result = self.ZCacheable_get(keywords=keyset)
              
               if result is not None:
                   # Got a cached value.
                   return result
           
           pt = getTemplate(self, "project_main")
            # Execute the template in a new security context.
           security.addContext(self)
   
           try:
               #logging.debug("index_html pt=%s"%repr(pt))
               result = pt.pt_render(extra_context=bound_names)
               #logging.debug("index_html result=%s"%repr(result))
               if keyset is not None:
                   # Store the result in the cache.
                   self.ZCacheable_set(result, keywords=keyset)
                  
               return result
           finally:
               security.removeContext(self)
          
   
         
       def index_html_old(self,request=True,context=None):
           """show homepage"""
         if not context:          if not context:
             context=self              context=self
         if request:          if request:
Line 1590  class MPIWGProject(CatalogAware,Folder): Line 1128  class MPIWGProject(CatalogAware,Folder):
                 self.REQUEST.SESSION['MPI_redirected']=None                  self.REQUEST.SESSION['MPI_redirected']=None
                   
     #ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])      #ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
         
         ext=getattr(self,"project_main",None)          ext=getattr(self,"project_main",None)
         if ext:          if ext:
             return getattr(self,ext.getId())()              return getattr(self,ext.getId())()
Line 1618  class MPIWGProject(CatalogAware,Folder): Line 1157  class MPIWGProject(CatalogAware,Folder):
   
     def getContent(self,field,filter=None):      def getContent(self,field,filter=None):
         """Inhalt des Feldes"""          """Inhalt des Feldes"""
           #logging.debug("getContent field=%s filter=%s"%(field,filter))
           
           if field=="short_title":
                   text = self.getContent("xdata_07")
                   if text=="":
                           text = self.getContent("WEB_title")
                   return text
                   
         text=u''          text=u''
   
Line 1638  class MPIWGProject(CatalogAware,Folder): Line 1184  class MPIWGProject(CatalogAware,Folder):
         except:          except:
             pass              pass
                   
         if text=='':          if text=='': ## wozu die folgenden Zeilen??
             text2=text              text2=text
         else:          else:
             text2=re.sub(r';([^\s])','; \g<1>',text)              text2=re.sub(r';([^\s])','; \g<1>',text)
   
           if field=="WEB_project_description":##Jedenfalls darf letzteres nicht gemacht werden, falls normaler text
               text2=text
               
         #teste ob ergebnis leer und header dann nehme title          #teste ob ergebnis leer und header dann nehme title
                   
         if (text2=='') and (field=='WEB_project_header'):          if (text2=='') and (field=='WEB_project_header'):
Line 1656  class MPIWGProject(CatalogAware,Folder): Line 1205  class MPIWGProject(CatalogAware,Folder):
                 try:                  try:
             self.imageURL=tmp[0].split("\"")[1].encode('utf-8')              self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
         except:          except:
                       try:
             self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')              self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
                       except:
                           self.imageURL=""
                   
                 split2="</p>".join(tmp[1:])                  split2="</p>".join(tmp[1:])
   
Line 1679  class MPIWGProject(CatalogAware,Folder): Line 1231  class MPIWGProject(CatalogAware,Folder):
         else:          else:
             text5=text2              text5=text2
   
         #teste ob WEB_project_description und keine führenden p tags          #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'):          if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
             text5= "<p>"+text5+"</p>"              text5= "<p>"+text5+"</p>"
   
   
         #filter image          #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
   
         return text5.encode('utf-8')  
   
     def showImagesOfPage(self,imageUrl=None):      def showImagesOfPage(self,imageUrl=None):
         """show Images of project"""          """show Images of project"""
Line 1709  class MPIWGProject(CatalogAware,Folder): Line 1267  class MPIWGProject(CatalogAware,Folder):
                   
     def saveEditedContent(self,kupu=None,preview=None):      def saveEditedContent(self,kupu=None,preview=None):
         """save Edited content"""          """save Edited content"""
           #logging.debug("saveEditedContent kupu=%s preview=%s"%(kupu,preview))
   
         if preview:          if preview:
             kupu=preview              kupu=preview
Line 1718  class MPIWGProject(CatalogAware,Folder): Line 1277  class MPIWGProject(CatalogAware,Folder):
         newcontent= kupu[start+6:end]          newcontent= kupu[start+6:end]
   
         if preview:          if preview:
               
             return self.preview(newcontent)              return self.preview(newcontent)
   
         self.copyObjectToArchive()          self.copyObjectToArchive()
           self.ZCacheable_invalidate()
         self.WEB_project_description=newcontent[0:]          self.WEB_project_description=newcontent[0:]
   
         self.REQUEST.RESPONSE.redirect("./index.html")          self.REQUEST.RESPONSE.redirect("./index.html")
                   
         return True          return True
   
     security.declareProtected('View managment screens','edit')      security.declareProtected('View management screens','edit')
     def edit(self):      def edit(self,western=None):
         """Edit pages"""          """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)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProjectNeu.zpt')).__of__(self)
         return pt()          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 getLabel(self):
           """returns label (or title) of this project"""
           l = self.getContent('xdata_07')
           if l:
               return l
           l = self.getContent('WEB_title')
           if l:
               return l
           return self.title
   
       def getBreadcrumbs(self):
           """return list of breadcrumbs from here to the root"""
           crumbs = []
           # skip direct parent Folder /projects/
           parent = self.aq_parent.aq_parent
           # get parents breadcrumbs
           if hasattr(parent, 'getBreadcrumbs'):
               crumbs = parent.getBreadcrumbs()
           
           # try to get acquisition URL from parent
           if hasattr(parent, 'absolute_url'):
               baseUrl = "%s/%s/"%(parent.absolute_url(), 'projects')
           else:
               baseUrl = "/en/research/projects/"
               
           # add in the internal project hierarchy
           
           ct=self.getContexts(parents=self.getContent('xdata_05'))
           # start with grandparents
           ct.reverse()
           for c in ct:
               label = shortenString(c[0].getLabel(), 13)
               crumbs.append((label, baseUrl+c[0].getId(), c[0]))            
   
           # add this project
           crumbs.append((self.getLabel(), baseUrl+self.getId(), self))
               
           return crumbs
   
       def getRootProject(self):
           """returns the root (=top level) project of the current project"""
           
           ct=self.getContexts(parents=self.getContent('xdata_05'))
           if len(ct) > 0:
               return ct[-1][0]
           else:
               return self        
   
   
     def preview(self,description):      def preview(self,description):
         """preview"""          """preview"""
           #logging.debug("preview description=%s"%description)
         tmpPro=getattr(self,"previewTemplate",None)          tmpPro=getattr(self,"previewTemplate",None)
         if not tmpPro:          if not tmpPro:
             tmpPro=MPIWGProject("previewTemplate")              tmpPro=MPIWGProject("previewTemplate")
Line 1743  class MPIWGProject(CatalogAware,Folder): Line 1366  class MPIWGProject(CatalogAware,Folder):
         for field in definedFields:          for field in definedFields:
             setattr(tmpPro,field,getattr(self,field))              setattr(tmpPro,field,getattr(self,field))
         tmpPro.WEB_project_description=description[0:]          tmpPro.WEB_project_description=description[0:]
                   tmpPro.invisible=True
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','previewFrame.zpt')).__of__(self)          pt=PageTemplateFile('zpt/previewFrame.zpt',globals()).__of__(self)
         return pt()          return pt()
   
         #return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"/previewTemplate")          #return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"/previewTemplate")
Line 1752  class MPIWGProject(CatalogAware,Folder): Line 1375  class MPIWGProject(CatalogAware,Folder):
   
     def getWebProject_description(self):      def getWebProject_description(self):
         """get description"""          """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</body>
               </html>
               """%self.WEB_project_description[0]
                   
         if type(self.WEB_project_description) is ListType:  
             return """              return """
             <html>              <html>
             <head>              <head>
             <meta http-equiv="Content-Type" content="text/html; charset=utf-8">              <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
             </head>              </head>
             <body>%s              <body>%s</body>
             </html></body>              </html>
             """%self.getContent('WEB_project_description')              """%self.getContent('WEB_project_description')
         else:          
             return self.WEB_project_description  
                   
                   
     def editMPIWGProjectForm(self):      def editMPIWGProjectForm(self):
Line 1771  class MPIWGProject(CatalogAware,Folder): Line 1403  class MPIWGProject(CatalogAware,Folder):
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)
         return pt()          return pt()
   
       def isResponsibleScientist(self,key):
           """teste ob eine Person in der Liste der respl. scientists auftaucht"""
           #logging.info("XXXXXXXXXXXXX"+repr(self.responsibleScientistsList))
     
           
           keys = [unicodify(x[1]) for x in getattr(self,"responsibleScientistsList",[])]
           #logging.error("RESP. SCIEN:%s"%getattr(self,"responsibleScientistsList",[]))
           #logging.error("RESP. SCIEN:%s"%unicodify(key))
           
           if unicodify(key) in keys:
               return True
           else:
               return False
           
       def getPersonKeyList(self):
           """gibt die key Liste der beteiligten Personen zurueck (utf8 codiert)"""
           #logging.error("getPersonKeyList:%s"%getattr(self,'responsibleScientistsList',[]))
           try:
               return [utf8ify(x[1]) for x in getattr(self,'responsibleScientistsList',[])]
           except:
               return[]
           
          
       def myCapitalize(self,txt):
           """kapitalisiere auch Namen mit -"""
           splitted=[x.capitalize() for x in txt.split("-")]
           return "-".join(splitted)
       
       def getNamesOrdered(self,list):
           """Sortiert die Liste nach der Reihenfolge in xdata_01"""
           
           nameList=self.getContent('xdata_01')
           if nameList.find(";")>-1: # rate Trenner ist ;
               names=nameList.split(";")  
           else:
               names=nameList.split(",")
               
           self._v_names=[]
           for name in names:
               self._v_names.append(name.rstrip().lstrip())
               
               
           def sort(x,y):
               try:
                   return cmp(self._v_names.index(x[0]),self._v_names.index(y[0]))
               except:
                   return 0
               
           list.sort(sort)
           
           return list
           
           ##nameList=nameList.replace(";",",") # falls ; als Trenner ersetze    
           
           
           
           
       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
           """
           
           if nameList.find(";")>-1: # rate Trenner ist ;
             names=nameList.split(";")  
             
           else:
               names=nameList.split(",")
               
           ##nameList=nameList.replace(";",",") # falls ; als Trenner ersetze    
           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
               
               firstname=self.myCapitalize(firstname).encode('utf-8')
               lastname=self.myCapitalize(lastname).encode('utf-8')
               logging.info("Search: %s %s %s"%(name,repr(firstname),repr(lastname)))
               try:
                   cataloggedNames=self.MembersCatalog(firstName=firstname,lastName=lastname)
               except:
                   cataloggedNames=[]
                   logging.error("ERROR: identifyNames %s %s"%sys.exc_info()[0:2])
               
               #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]=[]
          
           logging.error("id: %s"%repr(returnNamesDict))
           return returnNamesDict
           
     def editMPIWGProject(self,RESPONSE=None,fromEdit=None):      def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
         """edit the project and archive the old version"""          """edit the project and archive the old version"""
                   
         self.copyObjectToArchive() # archive the object          self.copyObjectToArchive() # archive the object
           self.ZCacheable_invalidate()
   
         for x in definedFields:          for x in definedFields:
             if self.REQUEST.has_key(x):              if self.REQUEST.has_key(x):
                                   
                 setattr(self,x,[self.REQUEST[x].decode('utf-8')])                  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():#schreibe keys und namen in die Liste, stelle ausserdem sicher, dass name unicode
                tmpList.append((unicodify(names[nr]),unicodify(keys.get(nr,""))))
                
           self.responsibleScientistsList=tmpList
         if fromEdit and (RESPONSE is not None):          if fromEdit and (RESPONSE is not None):
             RESPONSE.redirect('./editMPIWGBasisEditor')              #RESPONSE.redirect('./editMPIWGBasisEditor')
               return self.editMPIWGBasisEditor(identifiedNames=self.identifyNames(self.decode(self.REQUEST.get('xdata_01',''))))
   
         else:          else:
             if RESPONSE is not None:              if RESPONSE is not None:
Line 1811  class MPIWGProject(CatalogAware,Folder): Line 1590  class MPIWGProject(CatalogAware,Folder):
             if type(disciplines) is StringType:              if type(disciplines) is StringType:
                 self.xdata_09=disciplines                  self.xdata_09=disciplines
             else:              else:
                 self.xdata_09=string.join(disciplines,";")                  self.xdata_09=";".join(disciplines)
         else:          else:
                 self.xdata_09=""                  self.xdata_09=""
         if themes:          if themes:
             if type(themes) is StringType:              if type(themes) is StringType:
                 self.xdata_10=themes                  self.xdata_10=themes
             else:              else:
                 self.xdata_10=string.join(themes,";")                  self.xdata_10=";".join(themes)
         else:          else:
             self.xdata_10=""              self.xdata_10=""
   
         if fromEdit and (RESPONSE is not None):          if fromEdit and (RESPONSE is not None):
             RESPONSE.redirect('./editMPIWGDisciplinesThemesEditor')              self.redirect(RESPONSE,'./editMPIWGDisciplinesThemesEditor')
   
         else:          else:
             if RESPONSE is not None:              if RESPONSE is not None:
Line 1842  class MPIWGProject(CatalogAware,Folder): Line 1621  class MPIWGProject(CatalogAware,Folder):
         splitted=[y.rstrip().lstrip() for y in splitted]          splitted=[y.rstrip().lstrip() for y in splitted]
                   
         for x in splitted:          for x in splitted:
               x=re.sub(r"[^A-z ]","",x)
             if (not x==u'') and x in wert:              if (not x==u'') and x in wert:
                 return 1                  return 1
         return 0          return 0
   
     security.declareProtected('View management screens','editMPIWGBasisEditor')      security.declareProtected('View management screens','editMPIWGBasisEditor')
     def editMPIWGBasisEditor(self):      def editMPIWGBasisEditor(self, identifiedNames=None):
                               
         """editform"""          """editform"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)          if not identifiedNames:
         return pt()              identifiedNames=self.identifyNames(self.getContent('xdata_01'))
              # identifiedNames=self.getFullNameEntries()
   
           logging.error("IdentifiedNames: %s"% repr(identifiedNames))
           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):      def editMPIWGBasisForm(self):
         """editform"""          """editform"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)
         return pt()          return pt()
   
           security.declareProtected('View management screens','editMPIWGRelatedPublicationsForm')
     def editMPIWGRelatedPublicationsForm(self):      def editMPIWGRelatedPublicationsForm(self):
         """Edit related Publications"""          """Edit related Publications"""
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)
Line 1893  class MPIWGProject(CatalogAware,Folder): Line 1679  class MPIWGProject(CatalogAware,Folder):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
       def tagTheProject(self,RESPONSE=None):
           """TAG"""
           id=self.getId();
           tmpl =getattr(self.thesaurus,"main.html")
           if RESPONSE:
               RESPONSE.redirect("./thesaurus/main.html?project="+id)
           return
           
 def manage_addMPIWGProjectForm(self):  def manage_addMPIWGProjectForm(self):
     """form for adding the project"""      """form for adding the project"""
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)
Removed from v.1.47.2.23  
changed lines
  Added in v.1.47.2.123

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