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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.47.2.68 and 1.47.2.131

version 1.47.2.68, 2006/11/10 14:57:32 version 1.47.2.131, 2013/05/16 12:40:52
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
 #TODO: mechanismus fur links to personen ueberarbeiten, da jetzt alle e_mails als members auftauchen unabhaenig vom status publish_the_data  
 #TODO: was passiert wenn aenderungen von jochen im filemaker nicht mit den aenderungen im sql uebereinstimmen  
 #TODO: in einzelnen projecte steht als pfad auf die bilder noch wwwneu statt www  
   
   """
 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
 import xml.dom.minidom  from OFS.Cache import Cacheable
   import xmlrpclib
   #import xml.dom.minidom
 import sys  import sys
 from Ft.Xml.XPath import Evaluate  #from Ft.Xml.XPath import Evaluate
 from Ft.Xml.XPath.Context import Context  #from Ft.Xml.XPath.Context import Context
 from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print  #from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
 from Ft.Xml import EMPTY_NAMESPACE  #from Ft.Xml import EMPTY_NAMESPACE
 import copy  #import copy
   #import updatePersonalWWW
 definedFields=['WEB_title','xdata_01','xdata_02','xdata_03','xdata_04','xdata_05','xdata_06','xdata_07','xdata_08','xdata_09','xdata_10','xdata_11','xdata_12','xdata_13','WEB_project_header','WEB_project_description','WEB_related_pub']  
   
 checkFields = ['xdata_01']  
   
   
 def getTextFromNode(nodename):  
     nodelist=nodename.childNodes  
     rc = ""  
     for node in nodelist:  
         if node.nodeType == node.TEXT_NODE:  
            rc = rc + node.data  
     return rc  
   
   
 def sortStopWordsF(self,xo,yo):  
     if not hasattr(self,'_v_stopWords'):  
         self._v_stopWords=self.stopwords_en.data.split("\n")  
       
     x=str(xo[1])  
     y=str(yo[1])  
       
     strx=x.split(" ")  
     stry=y.split(" ")  
       
     for tmp in strx:  
         if tmp.lower() in self._v_stopWords:  
             del strx[strx.index(tmp)]  
       
     for tmp in stry:  
         if tmp.lower() in self._v_stopWords:  
             del stry[stry.index(tmp)]  
               
     return cmp(" ".join(strx)," ".join(stry))  
       
 def sortStopWords(self):  
     return lambda x,y : sortStopWordsF(self,x,y)  
       
 def sortF(x,y):  
     try:  
         return cmp(x[1],y[1])  
     except:  
         try:  
             return cmp(str(x[1]),str(y[1]))  
         except:             
               
             return 0   
       
 def sortI(x,y):  
     xsplit=x[1].split(".")  
     ysplit=y[1].split(".")  
     xret=""  
     yret=""  
     try:  
         for i in range(5):  
             try:  
                 yret=yret+"%04i"%int(xsplit[i])  
             except:  
                 yret=yret+"%04i"%0  
   
             try:  
                 xret=xret+"%04i"%int(ysplit[i])  
             except:  
                 xret=xret+"%04i"%0  
                   
           
         return cmp(int(yret),int(xret))  
     except:  
         return cmp(x[1],y[1])  
   
 class MPIWGLink(SimpleItem):  
     """create a symbolic link to another page"""  
   
     meta_type="MPIWGLink"  
       
     def isActiveItem(self):  
         """teste ob ausgewaehlt"""  
         #url1 beim link anstelle von url1, da link jeweils index_html als url hat.  
         if self.absolute_url()==self.REQUEST['URL1']:  
             return "aktiv"  
         else:  
             return ""  
   
     def __init__(self,id,link,title='',weight=''):  
         """init mpiwglink"""  
         self.id=id  
         self.link=link  
         self.title=title  
         self.weight=weight  
   
     def getObj(self):  
         """bekomme original"""  
        ##  objpath=self.link.replace("/",".")  
 ##         if objpath[0]!=".":  
 ##             objpath="."+objpath  
   
 ##         print objpath  
 ##         return eval("self"+objpath)  
   
   
         splitted=self.link.lstrip().split("/")  
         obj=self  
         for x in splitted:  
             if not x=="":  
               obj=getattr(obj,x)  
               
         return obj  
   
     def getWeight(self):  
         if self.linkWeight and linkWeight!="":  
             return self.linkWeight  
         else:  
             return self.getObj().weight  
   
     manage_options=(  #import MPIWGStaff
         {'label':'main config','action':'changeLinkForm'},  
         )+SimpleItem.manage_options  
   
   from MPIWGHelper import *
   
     def changeLinkForm(self):  import MPIWGRoot
         """change MPIWG link"""  import MPIWGLink
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGLinkChange.zpt')).__of__(self)  import MPIWGTemplate
         return pt()  
   
     def changeLink(self,link,title,weight,RESPONSE=None):  
         """change links"""  
         self.link=link  
         self.title=title  
         self.weight=weight  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage')  
   
     def index_html(self):  
         """index"""  
           
         try:  
             return self.getObj().pt_render(extra_context={'here':self})  
         except:  
             self.REQUEST.RESPONSE.redirect(self.getObj().absolute_url())  
                                          
   
 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)  
   
   
   import transaction
   
         self.ZBindings_edit(self._default_bindings)  # die folgenden Klassen sind jetzt in einzelne Files ausgelagert aus Kompatibilitaetsgruenden, bleiben die Klassen hier noch drin.
         if text is None:  # Sonst funktionieren die alten Webseiten nicht mehr.
             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)  
   
   class MPIWGRoot(MPIWGRoot.MPIWGRoot):
       """depricated"""
           
         """change form"""  class MPIWGLink(MPIWGLink.MPIWGLink):
       """depricated"""
     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  
   
   class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
       """depricated"""
   
 def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):  class MPIWGProject_publication(Folder):
     "Add a Page Template with optional file content."      """publications object fuer project"""
     if type(MPIWGType)==StringType:  
         MPIWGTypes=[MPIWGType]  
     else:  
         MPIWGTypes=MPIWGType  
           
     for singleType in MPIWGTypes:  
   
       meta_type="MPIWGProject_publication"
       def redirect(self,RESPONSE,url):
           """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
   
         if REQUEST is None:          timeStamp=time.time()
             self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))  
             ob = getattr(self, id)  
                           
             if title:          if url.find("?")>-1: #giebt es schon parameter
                 ob.pt_setTitle(title)              addStr="&time=%s"
             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:              else:
                 zpt = MPIWGTemplate(id, file, headers.get('content_type'))              addStr="?time=%s"
   
             self._setObject(id, zpt)          RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
             ob = getattr(self, id)          logging.debug(email.Utils.formatdate()+' GMT')
             if title:          RESPONSE.redirect(url+addStr%timeStamp)
                 ob.pt_setTitle(title)  
   
             try:      def hasLinkToBookPage(self,mode="not_cached"):
                 u = self.DestinationURL()          """teste ob eingebener link zu einer MPIWG Book page geht"""
             except AttributeError:  
                 u = REQUEST['URL1']  
   
     ob = getattr(self, id)  
     ob.weight=weight  
           
     REQUEST.RESPONSE.redirect(u+'/manage_main')          logging.debug("MPIWGProject_publication - begin hasLinkToBookPage")
     return ''          if (getattr(self,'link','')==''):
               return False #es gibt keinen link
   
           logging.debug("MPIWGProject_publication - begin hasLinkToBookPage:"+self.link)
           server = xmlrpclib.ServerProxy(self.link)
           
 class MPIWGRoot(ZSQLExtendFolder):          if(mode=="cached"):
     """Stammordner fuer den Web-Server"""              if (hasattr(self,"_v_hasLinkToBookPage")):
                   logging.debug("haslink cached")
                   return self._v_hasLinkToBookPage
   
     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 harvestProjects(self):  
         """harvest"""  
         folder="/tmp"  
         try:          try:
             os.mkdir("/tmp/harvest_MPIWG")              server.getImageUrls()
         except:              logging.debug("MPIWGProject_publication - end TRUE")
             pass              self._v_hasLinkToBookPage=True
         founds=self.ZopeFind(self.aq_parent.projects,obj_metatypes=['MPIWGProject'],search_sub=1)  
         for found in founds:  
             txt=found[1].harvest_page()  
           
             if txt and (txt != ""):  
                 name=found[0].replace("/","_")  
                 fh=file("/tmp/harvest_MPIWG/"+name,"w")  
                 fh.write(txt)  
                 fh.close()  
                   
     def decode(self,str):  
         """decoder"""  
         if not str:  
             return ""  
         if type(str) is StringType:  
         try:              
                 return str.decode('utf-8')  
         except:  
         return str.decode('latin-1')  
         else:  
               
             return str  
   
   
     def browserCheck(self):  
     """check the browsers request to find out the browser type"""  
     bt = {}  
     ua = self.REQUEST.get_header("HTTP_USER_AGENT")  
     bt['ua'] = ua  
     bt['isIE'] = False  
     bt['isN4'] = False  
     if string.find(ua, 'MSIE') > -1:  
         bt['isIE'] = True  
     else:  
         bt['isN4'] = (string.find(ua, 'Mozilla/4.') > -1)  
   
     try:  
         nav = ua[string.find(ua, '('):]  
         ie = string.split(nav, "; ")[1]  
         if string.find(ie, "MSIE") > -1:  
         bt['versIE'] = string.split(ie, " ")[1]  
     except: pass  
   
     bt['isMac'] = string.find(ua, 'Macintosh') > -1  
     bt['isWin'] = string.find(ua, 'Windows') > -1  
     bt['isIEWin'] = bt['isIE'] and bt['isWin']  
     bt['isIEMac'] = bt['isIE'] and bt['isMac']  
     bt['staticHTML'] = False  
   
     return bt  
   
   
     def versionHeaderEN(self):  
         """version header text"""  
           
         date= self.REQUEST.get('date',None)  
         if date:  
             txt="""<h2>This pages shows the project which existed at %s</h2>"""%str(date)  
             return txt  
         return ""  
   
     def versionHeaderDE(self):  
         """version header text"""  
         date= self.REQUEST.get('date',None)  
         if date:  
             txt="""<h2>Auf dieser Seite finden Sie die Projekte mit Stand vom %s</h2>"""%str(date)  
         return ""  
       
           
     def createOrUpdateId_raw(self):  
         """create sequence to create ids for bibliography"""  
         debug=None  
         #suche groesste existierende id  
         founds=self.ZSQLQuery("select id from bibliography")  
           
         if founds:  
             ids=[int(x.id[1:]) for x in founds]  
             maximum=max(ids)  
               
             id_raw=self.ZSQLQuery("select nextval('id_raw')",debug=debug)  
               
             if id_raw:  
                 self.ZSQLQuery("drop sequence id_raw",debug=debug)  
               
             self.ZSQLQuery("create sequence id_raw start %i"%(maximum+1),debug=debug)  
           
       
     def queryLink(self,link):  
         """append querystring to the link"""  
         return "%s?%s"%(link,self.REQUEST.get('QUERY_STRING',''))  
   
     def getKategory(self,url):  
         """kategorie"""  
         splitted=url.split("/")  
         return splitted[4]  
   
     def generateUrlProject(self,url,project=None):  
         """erzeuge aus absoluter url, relative des Projektes"""  
         if project:  
             splitted=url.split("/")  
             length=len(splitted)  
             short=splitted[length-2:length]  
               
             base=self.REQUEST['URL3']+"/"+"/".join(short)  
   
         else:  
             findPart=url.find("/projects/")  
             base=self.REQUEST['URL1']+"/"+url[findPart:]  
   
                   
         return base  
       
     def isNewCapital(self,text=None,reset=None):  
         if reset:  
             self.REQUEST['capital']="A"  
             return True  
         else:  
             if len(text)>0 and not (text[0]==self.REQUEST['capital']):  
                 self.REQUEST['capital']=text[0]  
                 return True                  return True
             else:  
                 return False  
       
     def subNavStatic(self,obj):  
         """subnav" von self"""  
         def sortWeight(x,y):  
             x1=int(getattr(x[1],'weight','0'))  
             y1=int(getattr(y[1],'weight','0'))  
             return cmp(x1,y1)  
         
         subs=self.ZopeFind(obj,obj_metatypes=['MPIWGTemplate','MPIWGLink'])  
         subret=[]  
   
         for x in subs:  
             if not(x[1].title==""):  
                 subret.append(x)  
         subret.sort(sortWeight)  
         return subret  
       
     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 getSection(self):  
         """returns the current section name"""  
         root = self.absolute_url()  
         url = self.REQUEST['URL']  
         path = string.replace(url, root, '')  
         paths = path.split('/')  
         if len(paths) > 0:  
             sec = paths[1]  
             if sec.find('.') < 0:  
                 return sec  
             else:  
                 return None  
         return None  
   
     def getSectionStyle(self, name, style=""):  
         """returns a string with the given style + '-sel' if the current section == name"""  
         if self.getSection() == name:  
             return style + '-sel'  
         else:  
             return style      
   
     def MPIWGrootURL(self):  
         """returns the URL to the root"""  
         return self.absolute_url()  
           
     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:
               logging.debug("MPIWGProject_publication - end FALSE ")
             """nothing"""              self._v_hasLinkToBookPage=True
         field=re.sub(r';([^\s])','; \g<1>',field)              return False
         return field.encode('utf-8')  
   
   
           
     def sortedNames(self,list):      def getImageUrls(self,mode="not_cached"):
         """sort names"""          """get the image urls"""
   
         def sortLastName(x_c,y_c):          if (getattr(self,'link','')==''):
             try:              return [] #es gibt keinen link
                 x=urllib.unquote(x_c).encode('utf-8','ignore')  
             except:  
                 x=urllib.unquote(x_c)  
   
             try:          server = xmlrpclib.ServerProxy(self.link)
                 y=urllib.unquote(y_c).encode('utf-8','ignore')  
             except:  
                 x=urllib.unquote(y_c)  
                                   
   
           if(mode=="cached"):
               if (hasattr(self,"_v_imageUrls")):
                   logging.debug("getImageURL cached")
                   return self._v_imageUrls
                           
             try:              try:
                 last_x=x.split()[len(x.split())-1]              urls = server.getImageUrls()
                 last_y=y.split()[len(y.split())-1]  
   
             except:  
   
                 last_x=""  
                 last_y=""  
               
               
               
             if last_x<last_y:  
                 return 1  
             elif last_x>last_y:  
                 return -1  
             else:  
                 return 0  
               
         list.sort(sortLastName)  
         list.reverse()  
           
         return list  
       
     def __init__(self, id, title):  
         """init"""  
         self.id=id  
         self.title=title  
   
     def removeStopWords(self,xo):  
         """remove stop words from xo"""  
         if not hasattr(self,'_v_stopWords'):  
             self._v_stopWords=self.stopwords_en.data.split("\n")  
       
         x=str(xo)  
       
         strx=x.split(" ")  
     
         for tmp in strx:  
        
             if tmp.lower() in self._v_stopWords:  
                 del strx[strx.index(tmp)]  
   
         return " ".join(strx)  
       
     def urlQuote(self,str):  
         """quote"""  
         return urllib.quote(str)  
   
     def urlUnQuote(self,str):  
         """quote"""  
         return urllib.unquote(str)  
       
           
   
     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry, date=None):  
         """gib alle Projekte aus mit Value von field mit fieldName enthaelt ein Element der Liste fieldContents"""  
         def sort(x,y):  
                 return cmp(x.WEB_title[0],y.WEB_title[0])  
   
         if type(fieldContentsEntry) is StringType:  
             fieldContentsTmp=[fieldContentsEntry]  
         else:  
             fieldContentsTmp=fieldContentsEntry  
   
         fieldContents=[]  
         for x in fieldContentsTmp:  
             fieldContents.append(" AND ".join(x.split()))  
         projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' AND')})  
         #print projects  
         #ret=[x for x in projects]  
         ret=[]  
         for x in projects:  
             obj=x.getObject()  
             obj=obj.getActualVersion(date)  
             if obj and (not getattr(obj,'invisible',None)):  
                 #if not (x in ret):  
                     ret.append(x)  
   
         ret.sort(sort)  
         return ret  
   
     def changeMPIWGRootForm(self):  
         """edit"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)  
         return pt()  
   
     def changeMPIWGRoot(self,title,disciplineList,themesList,connection_id,RESPONSE=None):  
         """change"""  
         self.title=title  
         self.connection_id=connection_id  
         self.disciplineList=disciplineList  
         self.themesList=themesList  
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def getDisciplineList(self):  
         """get disciplines as list"""  
         list= self.disciplineList.split("\n")  
         return [x.rstrip().lstrip() for x in list]  
       
     def getThemeList(self):  
         """get themes as list"""  
         list= self.themesList.split("\n")  
         return [x.rstrip().lstrip() for x in list]  
       
     def test(self):  
         """test"""  
         return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url  
   
     def getContexts(self,childs=None,parents=None,depth=None,date=None,onlyActive=True):  
         """childs alle childs, alle parents"""  
         ret=[]          ret=[]
               for url in urls:
                   url = os.path.join(self.link,url)
                   ret.append(url)
                   
         if parents:          except:
             splitted=parents.split(".")              self._v_imageUrls=[]
             parentId=string.join(splitted[0:len(splitted)-1],".")              return []
                   self._v_imageUrls=ret[0:]
             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 (onlyActive and project[0].isActiveProject()) or (not onlyActive):  
                     if re.match(searchStr,project[1]):  
                           
                         if depth:  
       
                             if int(depth)>=len(project[1].split("."))-len(childs.split(".")):  
                           
                                 ret.append(project)  
                         else:  
                             ret.append(project)  
         return ret  
       
     def getProjectFields(self,fieldName,date=None,folder=None,sort=None):  
         """getListofFieldNames"""  
         ret=[]  
       
         objects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'],search_sub=0)  
   
                   
         for object in objects:  
             obj=object[1]  
             obj=obj.getActualVersion(date)  
             if obj and (not getattr(obj,'invisible',None)):  
                 if fieldName=="WEB_title_or_short":  
   
                     if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer  
                         fieldNameTmp="WEB_title"  
                     else:  
                         fieldNameTmp="xdata_07"  
                 else:  
                     fieldNameTmp=fieldName  
   
                 ret.append((obj,obj.getContent(fieldNameTmp)))  
   
           
         if sort=="int":  
             ret.sort(sortI)  
         elif sort=="stopWords":  
    
             ret.sort(sortStopWords(self))  
               
         else:  
             ret.sort(sortF)  
           
         return ret          return ret
   
     def showNewProjects(self):      def editPublication(self,text=None,image1=None,image2=None,description=None,link=None,RESPONSE=None):
         projects=[]          """edit a publication"""
         for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets  
             if objs[0].xdata_05 and (objs[0].xdata_05[0] == ""):  
                   
                 projects.append(objs)  
                   
         return projects  
       
           
     manage_options = Folder.manage_options+(  
         {'label':'Update personal homepages','action':'updateHomepages'},  
         {'label':'Reindex catalogs','action':'reindexCatalogs'},  
         {'label':'Main config','action':'changeMPIWGRootForm'},  
         #{'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},  
         #{'label':'Store Historical Persons','action':'storeHistoricalPersons'},  
         )  
           
     def importNamesForm(self):          if (not text) and (not description):
         """Form"""              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGNamesForm.zpt')).__of__(self)  
         return pt()          return pt()
   
     def importNames(self,fileupload,folderName,RESPONSE=None):  
         """import komma-sep list email,lastName,firstName"""  
         project=getattr(self,folderName)  
         load=fileupload.read()  
           
         for line in load.split('\r'):  
               
               
             splitted=line.split(",")  
            # print splitted  
                   
             if not (splitted[0]==""):          if text:
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])              self.text=text[0:]
                   
                 try:  
                     project._setObject(splitted[0],newObj)  
                     #print "done:",splitted[0]  
                 except:  
                     zLOG.LOG("MPIWG Web (importNames)",zLOG.INFO,"cannot import: %s"%splitted[0])  
   
                       
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def updatePublicationDB(self,personId=None):  
         """updates the publication db, i.e. copy year into the main table"""  
           
         if personId:  
             founds = self.ZSQLInlineSearch(_table="publications",id_main=personId)  
         else:  
             founds = self.ZSQLInlineSearch(_table="publications")  
               
         for found in founds:  
                           
             if found.id_institutsbibliographie and (not found.id_institutsbibliographie =="") and (not found.id_institutsbibliographie =="0"):  
                   
                 entries = self.ZSQLInlineSearch(_table="institutsbiblio",id=found.id_institutsbibliographie)  
                 for entry in entries:  
                     self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)  
                       
             if found.id_gen_bib and (not found.id_gen_bib ==""):  
                 entries = self.ZSQLInlineSearch(_table="bibliography",id=found.id_gen_bib)  
                 for entry in entries:  
                     self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)  
                       
         return True          
                   
     def updateHomepages(self,RESPONSE=None):          if description:
         """ update"""              self.description=description
                   
         RESPONSE.setHeader('Content-type', 'text/html')          if link:
         RESPONSE.write("<html><body>\n")              self.link=link[0:]
         RESPONSE.write("Update Institutsbibliography\n")  
         ret=self.upDateSQL('personalwww.xml')  
         RESPONSE.write("done Insitutsbibliography:%s\n"%ret)  
         url="http://itgroup.mpiwg-berlin.mpg.de:8050/FMPro?-db=personal-www&-format=-dso_xml&-lay=sql_export&-max=20000&-findall"  
         dom = NonvalidatingReader.parseUri(url)  
         #fh=urllib.urlopen(url)  
         #dom=xml.dom.minidom.parse(fh)  
   
         RESPONSE.write("got_xml_File\n")  
           
           
         memberFolder=getattr(self,'members')  
         members=memberFolder.ZopeFind(memberFolder,obj_metatypes=["MPIWGStaff"])  
           
         memberList=[x[0] for x in members]  
         #print dom  
         #ctx=Context(dom,processorNss={EMPTY_NAMESPACE:'http://www.filemaker.com/fmpdsoresult'})  
         # Evaluate(u".//dn:ROW",contextNode=dom,explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})  
         #print dom.xpath(u'.//dn:ROW',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})  
         for row in dom.xpath(u'.//dn:ROW',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'}):  
           
             username=getTextFromNode(row.xpath('./dn:username',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             id=getTextFromNode(row.xpath('./dn:ID',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             name=getTextFromNode(row.xpath('./dn:Name',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             vorname=getTextFromNode(row.xpath('./dn:Vorname',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             title=getTextFromNode(row.xpath('./dn:Title',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             position=getTextFromNode(row.xpath('./dn:Position',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             e_mail=getTextFromNode(row.xpath('./dn:e_mail',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             e_mail_p=getTextFromNode(row.xpath('./dn:e_mail_p',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             date_from=getTextFromNode(row.xpath('./dn:Date_from',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             date_to=getTextFromNode(row.xpath('./dn:Date_to',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             abteilung=getTextFromNode(row.xpath('./dn:Abteilung',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             heimat_inst=getTextFromNode(row.xpath('./dn:heimat_inst',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             funded_by=getTextFromNode(row.xpath('./dn:funded_by',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             e_mail2=getTextFromNode(row.xpath('./dn:e_mail2',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             publish_the_data=getTextFromNode(row.xpath('./dn:publish_the_data',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             stay_at_mpiwg=getTextFromNode(row.xpath('./dn:stay_at_mpiwg',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
             #cwNode=row.xpath('./dn:current_work.current',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0]  
             cw=row.xpath('./dn:current_work/dn:DATA',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})  
             if cw:  
                 txt=getTextFromNode(cw[0])  
             else:  
                 txt=""  
              
             #cwNode=row.xpath('.//dn:current_work.publish',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0]  
             cw=row.xpath('./dn:current_work/dn:DATA',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})  
   
             if cw:          if image1:
                 txt_p=getTextFromNode(cw[0])              if hasattr(self,'publicationImage1'):
                   self.publicationImage1.manage_upload(image1)
             else:              else:
                 txt_p=""                  nO = Image('publicationImage1','',image1)
                                self._setObject('publicationImage1',nO)
             project=getattr(self,'members')  
                           
             if not (username in memberList):#neuer eintrag          if image2:
                               if hasattr(self,'publicationImage2'):
                 try:                  self.publicationImage2.manage_upload(image2)
                     newObj=MPIWGStaff.MPIWGStaff(str(username),name.encode('utf-8'),vorname.encode('utf-8'))  
                     memberFolder._setObject(str(username),newObj)  
                     RESPONSE.write("<p>new:%s</p>\n"%username.encode('utf-8'))  
                     obj=getattr(memberFolder,username)  
                     ret=obj.createNewDBEntry(publish_the_data,id,name,  
                                           vorname,username,title,position,e_mail,  
                                           e_mail_p,date_from,date_to,  
                                           abteilung,heimat_inst,funded_by,  
                                           e_mail2,txt,txt_p,stay_at_mpiwg)  
                     RESPONSE.write("""<p>%s</p>"""%ret[1].encode('utf-8'))  
                 except:  
                     RESPONSE.write("<p>ERROR:%s %s %s</p>\n"%(username.encode('utf-8'),name.encode('utf-8'),vorname.encode('utf-8')))  
                     RESPONSE.write("<p>      : %s %s"%sys.exc_info()[:2])  
             else:              else:
                 RESPONSE.write("<p>update:%s</p>\n"%username.encode('utf-8'))                  nO = Image('publicationImage2','',image2)
                                   self._setObject('publicationImage2',nO)
                 xquery=".//dn:ROW[dn:username='%s']"%username  
                 results=dom.xpath(xquery,explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})  
                 if len(results)>1:  
                     RESPONSE.write("<p>WARNING (update): username %s not unique</p>\n"%username.encode('utf-8'))  
                     xquery=".//dn:ROW[dn:publish_the_data='yes' and dn:username='%s']"%username  
                     rd=dom.xpath(xquery,explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})   
                     if len(rd)>1:#mehrere published  
                         RESPONSE.write("<p>ERROR (update): username %s not unique and more then one date  set to be published</p>\n"%username.encode('utf-8'))  
 #                    elif len(rd)==1:#nur einer published, kein published dann mache nichts  
 #                        publish_the_data=getTextFromNode(rd[0].xpath('./dn:publish_the_data',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
 #                        date_from=getTextFromNode(rd[0].xpath('./dn:Date_from',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
 #                        date_to=getTextFromNode(rd[0].xpath('./dn:Date_to',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  
 #                
   
                 obj=getattr(memberFolder,username)  
                   
                 done= obj.updateDBEntry(DBid=id,publish_the_data=publish_the_data,  
                                    date_from=date_from,  
                                    date_to=date_to,stay_at_mpiwg=stay_at_mpiwg,position=position,abteilung=abteilung)  
                 if not done and (publish_the_data=='yes'):  
                           
                     ret=obj.createNewDBEntry(publish_the_data,id,name,  
                                           vorname,username,title,position,e_mail,  
                                           e_mail_p,date_from,date_to,  
                                           abteilung,heimat_inst,funded_by,  
                                           e_mail2,txt,txt_p,stay_at_mpiwg)  
                     if not ret[0]:  
   
                             RESPONSE.write("<p>Error: %s</p>\n"%repr(ret[1]))  
                     else:  
                         RESPONSE.write("<p>New: %s</p>\n"%repr(ret[1]))  
   
         #TODO: reindexCatlogs and updatePublications wieder einbaue  
         #self.reindexCatalogs(RESPONSE)  
       
         #self.updatePublicationDB()  
    
         #self.ZSQLResetConnection()  
         RESPONSE.write("<h2>Done</h2></body></html>")  
                      
         return True  
        
     def reindexCatalogs(self,RESPONSE=None):  
         """reindex members and project catalog"""  
           
           
         try:  
             self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])  
             self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])  
         except:  
             zLOG.LOG("MPIWG Root (updatehomepage)",zLOG.WARNING," %s %s"%sys.exc_info()[:2])  
               
           
       
                   
                         
           self.ZCacheable_invalidate()
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect('manage_main')              self.redirect(RESPONSE,"../managePublications")
   
           
           
     def updateHomepages_old(self,RESPONSE):  
         """lege members an, alte version vollstaendige kopie aller fm-dateien per fm.jar"""  
         self.upDateSQL('personalwww.xml')  
         founds=self.ZSQLInlineSearch(_table='personal_www',publish_the_data='yes')  
         project=getattr(self,'members')  
         for found in founds:  
               
             if not (found.e_mail==""):  
                 newObj=MPIWGStaff.MPIWGStaff(found.username,found.name,found.vorname)  
                   
                 try:  
                     project._setObject(found.username,newObj)  
                     RESPONSE.write("<p>new:%s</p>\n"%found.username)  
                 except:  
                     RESPONSE.write("<p>old:%s (%s,%s)</p>\n"%(found.username,found.name,found.vorname))  
   
                   
   
         #delete non existing  
   
   
         foundUserNames=[x.username for x in founds]  
         for member in self.ZopeFind(self,obj_metatypes=["MPIWGStaff"],search_sub=1):              
               
             if member[1].getId() not in foundUserNames:  
                 member[1].aq_parent.manage_delObjects(ids=[member[1].getId()])  
                 RESPONSE.write("<p>deleted:%s</p>\n"%member[1].getId())  
         try:  
             self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])  
         except:  
             pass  
         self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])  
       
         self.updatePublicationDB()   
              
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
           
 #    def getAllMembers(self,reset=None):  
 #        """give list of all members"""  
 #        ret=[]  
 #  
 #  
 #        if reset or (getattr(self,'_v_membersList',None) is None):  
 #            for member in self.members._objects:  
 #                if member['meta_type']=='MPIWGStaff':  
 #                    memberObj=getattr(self.members,member['id'])  
 #                    if memberObj.isPublished():  
 #                           ret.append(memberObj.title.decode('utf-8'))  
 #              
 #            ret.sort()  
 #            self._v_membersList=ret[0:]  
 #        print ret  
 #    
 #        return self._v_membersList  
   
     def getAllMembers(self):  
         #ret=[]  
           
         results=self.MembersCatalog({'isPublished':True})  
    
         ret=[", ".join([proj.lastName, proj.firstName]).decode('utf-8') for proj in results]  
           
     ret.sort()  
         return ret  
     def printAllMembers(self):  
         """print"""  
         members=self.getAllMembers()  
         ret=""  
         for x in members:  
             ret+="<p>%s</p>"%x  
         return ret  
       
           
     def makeList(self,entry):  
         """makes a list out of one entry or repeat a list"""  
         if type(entry) is StringType:  
             return [entry]  
         else:  
             return entry  
   
   
     def getTree(self,dep=None,date=None,onlyActive=None):  
         """generate Tree from project list"""  
   
         returnList=[]  
         for project in self.getProjectFields('xdata_05',sort="int",date=date): # get Projects sorted by xdata_05  
   
             for idNr in project[1].split(";"): # more than one number  
                 if not idNr=="":  
                     splittedId=idNr.split(".")  
                     depth=len(splittedId)  
                     nr=idNr  
                     #title=project[0].WEB_title  
                     title=[project[0].getContent('WEB_title')]  
                     #print title  
                       
                     if idNr[0]=="x": # kompatibilitaet mit alter Konvention, x vor der Nummer macht project inactive  
                         project[0].setActiveFlag(False)  
                      
                     if (not dep) or (idNr[0]==dep): #falls dep gesetzt ist nur dieses hinzufuegen.  
                         if onlyActive and project[0].isActiveProject(): #nur active projekte  
                            returnList.append((depth,nr,title,project[0]))  
                         elif not onlyActive:  
                           returnList.append((depth,nr,title,project[0]))  
         return returnList  
   
     def formatElementsAsList(self,elements,onlyOneDept=False):  
         """formatiere tree als liste"""  
           
         actualDepth=0  
         ret=""  
         for element in elements:  
             if (element[0]>actualDepth):  
                 #fuege soviele ul ein wie unterschied in tiefe  
                 if element[0]==1:  
                     ret+="""<div class="dept">\n<ul class="liste">\n"""  
                 else:  
                     for i in range(element[0]-actualDepth):  
                         if i>0:  
                             ret+="<li>"  
                         ret+="""<ul class="liste">\n"""  
   
                 actualDepth=element[0]  
                   
             elif (element[0]<actualDepth):  
                 #fuege soviele /ul ein wie unterschied in tiefe  
                 for i in range(-element[0]+actualDepth):  
   
                     ret+="<br><br></li></ul>\n"  
   
                     #ret+="<br><br>\n</li>\n</ul>\n</li>\n"  
   
   
                 if element[0]==1:  
                     department=int(element[3].getContent('xdata_05'))-1  
                       
                     ret+="""</ul></div>\n"""  
                     if department==4: #hack  
                         department=3  
   
                     ret+="""<div class="bildspalte"><img src="../grafik/dept%i.jpg" width="160" height="120" vspace="40"></div>  
                     <div class="dept">\n<ul class="liste">\n  
                     """%department  
               
                 actualDepth=element[0]  
             else:  
                 ret+="""\n</li>\n"""  
             ret+="""<li>\n"""  
               
             if actualDepth==1:  
                 departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'Ind. Research Group','5':'Ind. Research Group','6':'Ind. Research Group','7':'Research Network'}   
                 department=element[3].getContent('xdata_05')  
                 if not onlyOneDept:  
                     ret+="""<a href="#top"><img src="../grafik/totop.gif" vspace="10" border="0"></a><br><a name="dept%s"></a>%s: """%(department,departmentName[department])  
   
             if self.REQUEST.has_key('date'):  
                 ret+="""<a href="%s?date=%s">%s</a>"""%(self.generateUrlProject(element[3].absolute_url())+"/index.html",self.REQUEST['date'],element[3].getContent('WEB_title'))  
             else:  
                 ret+="""<a href="%s">%s</a>"""%(self.generateUrlProject(element[3].absolute_url())+"/index.html",element[3].getContent('WEB_title'))  
         return ret  
       
     def formatElementForOverview(self,element):  
         """format the element for output in overview"""  
         if element[0]==1: #department  
             #print element[3].getContent('xdata_05')  
             if element[3].getContent('xdata_05') == "4":  
                 return """<h2 class="hier"><a href="%s">Ind. Research Group I: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))  
             if element[3].getContent('xdata_05') == "5":  
                 return """<h2 class="hier"><a href="%s">Ind. Research Group II: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))  
             if element[3].getContent('xdata_05') == "6":  
                 return """<h2 class="hier"><a href="%s">Research Network "History of Scientific Objects": %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))  
               
             return """<h2 class="hier"><a href="%s">Department %s: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('xdata_05'),element[3].getContent('WEB_title'))  
   
         elif element[0]==2: #mainprojects  
             return """<h3 class="hier"><a href="%s">%s</a></h3><p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))  
   
         elif element[0]==3:  
             return """<p class="hier"><a href="%s">%s</a></p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))  
   
           
     def changePosition(self,treeId,select,RESPONSE=None):  
         """Change Postion Entry"""  
         numbers=[]  
   
         # Suche hoechste bisherige nummer  
         projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05  
         #print "pj",projects  
         for project in projects: #suche alle subtrees der treeId  
             #print treeId  
               
             founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])  
             if founds:  
                 #print "x",founds.group(0),len(founds.group(0).split("."))  
                 if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene  
                     try:  
                         numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))  
                     except:  
                         numbers.append(int(0))  
   
         try:  
             highest=max(numbers)  
         except:  
             highest=0  
         projects=self.showNewProjects()  
         for i in self.makeList(select):  
             highest+=10  
             projects[int(i)][0].xdata_05=treeId+"."+str(highest)  
   
   
         if RESPONSE is not None:  
             RESPONSE.redirect('showTree')  
           
     def changeTree(self,RESPONSE=None):  
         """change the complete tree"""  
         form=self.REQUEST.form  
         hashList={}  
         fields=self.getTree()  
   
           
         for idNr in form.keys():  
               
             splitted=idNr.split('_')  
               
             if len(splitted)==1: # name des Feldes = idNr, dann Aendere id_nr  
                 if not (fields[int(idNr)][3].xdata_05==form[idNr]):  
                     fields[int(idNr)][3].xdata_05=form[idNr]  
                     fields[int(idNr)][3].copyObjectToArchive()  
                                           
                 if form.has_key(idNr+'_active'): # active flag is set  class MPIWGProject_relatedProject(Folder):
                         """publications object fuer project"""
                     fields[int(splitted[0])][3].setActiveFlag(True)  
                 else:  
                     
                     fields[int(splitted[0])][3].setActiveFlag(False)  
                       
         if RESPONSE is not None:  
             RESPONSE.redirect('showTree')  
   
     def getProjectWithId(self,id):  
         fields=self.getProjectFields('xdata_05')  
         for field in fields:  
             if field[1]==id:  
                 return field[0]  
   
         return None  
               
           
               
           
     def getRelativeUrlFromPerson(self,list):  
         """get urls to person list"""  
         ret=[]  
         persons=list.split(";")  
         for person in persons:  
               
             if len(person)>1: #nicht nur Trennzeichen  
                 splitted=person.split(",")  
                 if len(splitted)==1:  
                     splitted=person.split(" ")  
                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]  
                 if splittedNew[0]=='':  
                     del splittedNew[0]  
                 search=string.join(splittedNew,' AND ')  
                   
                 if not search=='':  
   
                     try:  
                         proj=self.MembersCatalog({'title':search})  
                     except:  
                         proj=None  
   
                 if proj:  
                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))  
                     ret.append("<a href=%s >%s</a>"%('members/'+proj[0].id+'/index.html',person))  
                 else:  
                     #ret.append("%s"%person.encode('utf-8'))  
                     ret.append("%s"%person)  
         return string.join(ret,";")  
           
               
     def getMembersFromList(self,list):  
         """get member names from person full text list"""  
         memberlist=[]  
         persons=list.split(";")  
         for person in persons:  
             if len(person)>1: #nicht nur Trennzeichen  
                 splitted=person.split(",")  
                 if len(splitted)==1:  
                     splitted=person.lstrip().rstrip().split(" ")  
                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]  
                 if splittedNew[0]=='':  
                     del splittedNew[0]  
                 search=string.join(splittedNew,' AND ')  
                   
                 if not search=='':  
                     try:  
                         member=self.MembersCatalog({'title':search})  
                     except:  
                         member=None  
   
                 if member and (member[0].getObject().isPublished()):  
                     if person =="Otto Sibum" : person="H. Otto Sibum"  
                     if person =="Norton Wise" : person="M. Norton Wise"  
                     #memberlist.append("<a href=%s >%s</a>"%(member[0].absolute_url,person.encode('utf-8')))  
                     memberlist.append((person, member[0].getObject().getId()))  
                 else:  
                     #memberlist.append("%s"%person.encode('utf-8'))  
                     memberlist.append((person,None))  
         return memberlist  
                            
     def getUrlFromPerson(self,list):  
         """get urls to person list"""  
         ret=[]  
         persons=list.split(";")  
         for person in persons:  
               
             if len(person)>1: #nicht nur Trennzeichen  
                 splitted=person.split(",")  
                 if len(splitted)==1:  
                     splitted=person.lstrip().rstrip().split(" ")  
                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]  
                 if splittedNew[0]=='':  
                     del splittedNew[0]  
                 search=string.join(splittedNew,' AND ')  
                   
                 if not search=='':  
   
                     try:  
                         proj=self.MembersCatalog({'title':search})  
                     except:  
                         proj=None  
   
                 if proj and (proj[0].getObject().isPublished()):  
                     if person =="Otto Sibum" : person="H. Otto Sibum"  
                     if person =="Norton Wise" : person="M. Norton Wise"  
                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))  
             if self.MPIWGrootURL().split("/")[-1]=='en':  
             tmpPath="/en/staff/members/"  
             else:  
                         tmpPath="/de/mitarbeiter/members/"  
                     ret.append("<a href=%s >%s</a>"%(tmpPath+proj[0].getObject().getId()+"/index.html",person))  
                 else:  
                     #ret.append("%s"%person.encode('utf-8'))  
                     ret.append("%s"%person)  
         return string.join(ret,";")  
                            
     def getProjectsOfMembers(self,date=None):  
         """give tuple member /projects"""  
         ret=[]  
         members=self.getAllMembers()  
          
         #return str(members)  
         for x in members:  
            
             ret+=self.getProjectsOfMember(name=x,date=date)  
               
         return ret  
   
     def getProjectsOfMember(self,name=None,email=None,date=None):  
         """get project of a member"""  
         def sortP(x,y):  
             """sort by sorting number"""  
             #print x.xdata_05,y.xdata_05  
             return cmp(x.WEB_title,y.WEB_title)  
           
          
         ret=[]  
         splitNeu=[]  
         if email:  
               
             members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email],search_sub=1)  
             name =  members[0][1].title.decode('utf-8')  
   
         y=name  
         splitted=y.split(",")  
         #XXXX  
         splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]  
           
         #for s in splitted:  
         #    splitNeu.append("\""+s+"\"")  
         search=string.join(splitNeu,' AND ')  
           
         proj=self.ProjectCatalog({'xdata_01':search})  
   
         if proj:  
             proj2=[]  
             for x in proj:  
                 if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):  
                     if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):  
                        proj2.append(x)  
   
         else:  
             proj2=[]  
               
         proj=self.ProjectCatalog({'xdata_08':search})  
         if proj:  
             names=[x.WEB_title for x in proj]  
             for x in proj:  
                   
                 if (not x.WEB_title in names) and (getattr(x.getObject(),'archiveTime','')==''):  
                     proj2.append(x)  
   
   
         proj2.sort(sortP)  
   
         if len(proj2)>0:  
             ret.append((y,proj2))  
   
         return ret  
        
     def givePersonList(self,name):  
         """check if person is in personfolder and return list of person objects"""  
                   
         splitted=name.split(",")      meta_type="MPIWGProject_relatedProject"
         if len(splitted)==1:      def redirect(self,RESPONSE,url):
             splitted=name.lstrip().rstrip().split(" ")          """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
         splittedNew=[split.lstrip() for split in splitted]  
           
         if splittedNew[0]=='':  
             del splittedNew[0]  
         search=string.join(splittedNew,' AND ')  
                   
         if not search=='':          timeStamp=time.time()
             proj=self.MembersCatalog({'title':search})  
   
         if proj:          if url.find("?")>-1: #giebt es schon parameter
             return [[x.lastName,x.firstName] for x in proj]              addStr="&time=%s"
         else:          else:
             return []              addStr="?time=%s"
                           
 ##         splitted=name.split(",") # version nachname, vorname...          RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
 ##         if len(splitted)>1:          logging.debug(email.Utils.formatdate()+' GMT')
 ##             lastName=splitted[0]           RESPONSE.redirect(url+addStr%timeStamp)
 ##             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=[]      def editRelatedProject(self,link=None,RESPONSE=None):
           """edit a publication"""
         #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):          if (not link):
         """return checklist"""              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_relatedProjectForm.zpt')).__of__(self)
         #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 generateNameIndex(self):  
         """erzeuge einen index verwendeter personen"""  
         import psycopg  
         o = psycopg.connect('dbname=authorities user=dwinter password=3333',serialize=0)   
         results={}  
         print self.fulltext.historicalNames.items()  
         for nameItem in self.fulltext.historicalNames.items(): #gehe durch alle namen des lexikons  
               
             c = o.cursor()   
             name=nameItem[0]  
             print "check",name  
             c.execute("select lastname,firstname from persons where lower(lastname) = '%s'"%quote(name))  
             tmpres=c.fetchall()  
             firstnames=[result[1] for result in tmpres] # find all firstnames  
             if tmpres:  
                 lastname=tmpres[0][0]  
                   
             for found in self.fulltext({'names':name}):  
                 if found.getObject().isActual():  
                     for nh in found.getObject().getGetNeighbourhood(name, length=50,tagging=False): #hole umgebung  
                         #schaue nun ob der vorname hinter oder vor dem name ist  
                         position=nh.find(lastname)  
                         # vorher  
                         #print "NH",nh  
                         bevorS=nh[0:position].split()  
                         #print "BV",bevorS  
                         if len(bevorS)>1:  
                             try:  
                                 bevor=[bevorS[-1],bevorS[-2]]  
                             except:  
                                 bevor=[bevorS[0]]  
                         else:  
                             bevor=[]  
                         #nachher  
                         behindS= re.split("[,|;| ]",nh[position:])   
                         #print "BH",behindS  
                         if len(behindS)>2:  
                             try:  
                                 behind=behindS[1:3]  
                             except:  
                                 behind=[bevorS[1]]  
                         else:  
                             behind=[]  
                         for firstname in firstnames:  
                             if firstname in bevor+behind: #Namen wie mit Adelspraedikaten werden so erstmal nich gefunden  
                                 id="%s,%s"%(lastname,firstname)  
                                 if not results.has_key(id):  
                                     results[id]=[]  
                                 objId=found.getObject().getId()  
                                 if not (objId in results[id]):  
                                     print "d %s for %s"%(id,objId)      
                                     results[id].append(objId)      
             self.nameIndex=results  
         return results  
                       
     def editNameIndexHTML(self):  
         """edit the name index"""  
         if not hasattr(self,'nameIndexEdited'): # falls editierter index noch nicht existiert, kopiere automatisch erstellten  
             self.nameIndexEdited=copy.copy(self.nameIndex)  
             print "huh"  
         #self.nameIndexEdited=copy.copy(self.nameIndex)  
         #print self.nameIndexEdited  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalNames.zpt')).__of__(self)  
         return pt()          return pt()
           
     def getNamesInProject(self,projectId):  
         """get all names ofnameIndexEdited which are references in projec with projectId"""  
                   
         ret=[]  
         for name in self.nameIndexEdited.keys():  
             if projectId in self.nameIndexEdited[name]:  
                 ret.append(name)  
                   
         return ret  
           
     def editNameIndex(self,RESPONSE=None,name=None,occurrances=None,submit=None):  
         """edit the index"""  
         nI=self.nameIndexEdited # mI introduced to make sure that changes to nameIndexEdited are know to ZODB  
         if submit=="delete":  
                         
           # hole die id des projektes
           splitted=link.split("/")
   
             dh=getattr(self,'deletedHistoricalNames',{})          #teste ob es das project gibt
             if not dh.has_key(name):          if len(splitted)<1:
                 dh=occurrances.split("\n")              self.redirect(RESPONSE,'errorRelatedProjects?link='+link)
             else:  
                 dh+=occurrances.split("\n")  
                           
             self.deletedHistoricalNames=dh          objid=splitted[-1]
           object = getattr(self.projects,objid,None)
                           
             del self.nameIndexEdited[name]          if object==None:
               self.redirect(RESPONSE,'errorRelatedProjects?link='+link)
                           
                   
         elif (submit=="change"):  
                           
             nI[name]=occurrances.split("\n")[0:]  
                           
         elif (submit=="add"):  
             if not nI.has_key(name):  
                 nI[name]=occurrances.split("\n")  
             else:  
                 nI[name]+=occurrances.split("\n")  
           
         self.nameIndexEdited=nI          self.orginallink=link[0:]
           self.objid=objid[0:]
         
           self.projectWEB_title=object.getContent('WEB_title')[0:]
               
         if RESPONSE is not None:          self.enabled=True;
             RESPONSE.redirect('editNameIndexHTML')          self.ZCacheable_invalidate()
           
       
       
     def restoreIndex(self):  
         """restore"""  
         self.nameIndexEdited=self.nameIndex  
         return "done"  
       
     def changeHistoricalNames(self,projId,nameListTmp):  
         """add resp change nameIndexEdited b  
         y adding/changing names menitionen in project projId"""  
           
         #clear namelist from blanks  
         nameList=[x.lstrip().rstrip() for x in nameListTmp]  
           
         nI=self.nameIndexEdited  
         for name in nameList:  
             if not nI.has_key(name): #neuer Name  
                 nI[name]=[projId]  
           
         for name in nI.keys():  
     
             if name in nameList: #checke if name in name List  
                
                 if not(projId in nI[name]): #nicht in listt -> hinzufuegen  
                     
                     nI[name].append(projId)  
                   
                 """loesche falls projekt in nI list aber der name nicht mehr   
                 in der namensliste des projectes auftaucht   
                 """  
                  
             for pr in nI[name]:  
               
                 if (pr==projId) and (not name in nameList):   
                    
                     nI[name].remove(pr)  
   
         self.nameIndexEdited=nI    
           
       
               
 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:          if RESPONSE:
             RESPONSE.redirect("../managePublications")              self.redirect(RESPONSE,"../manageRelatedProjects")
                           
 class MPIWGProject_image(Image):  class MPIWGProject_image(Image):
     """Images for Projects"""      """Images for Projects"""
Line 1666  class MPIWGProject_image(Image): Line 248  class MPIWGProject_image(Image):
             self.caption=caption[0:]              self.caption=caption[0:]
   
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect("../manageImages")              self.redirect(RESPONSE,"../manageImages")
   
 class MPIWGProject(CatalogAware,Folder):  class MPIWGProject(CatalogAware,Folder,Cacheable):
     """Class for Projects"""      """Class for Projects"""
   
       def _p_resolveConflict(self, oldState, savedState, newState):
           return newState
   
     security=ClassSecurityInfo()      security=ClassSecurityInfo()
     meta_type='MPIWGProject'      meta_type='MPIWGProject'
     default_catalog='ProjectCatalog'      default_catalog='ProjectCatalog'
   
       def redirect(self,RESPONSE,url):
           """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
           
           timeStamp=time.time()
           
           if url.find("?")>-1: #giebt es schon parameter
               addStr="&time=%s"
           else:
               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 decode(self,str):
           """return unicode object"""
           return unicodify(str)
     
     def sortedByPlace(self,metatype):      def sortedByPlace(self,metatype):
         """find metatype and sort by place"""          """find metatype and sort by place"""
         def sort(x,y):          def sort(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))
   
           logging.debug("MPIWGProjects begin: sorted by place: "+ metatype)
         founds=self.ZopeFind(self,obj_metatypes=[metatype]);          founds=self.ZopeFind(self,obj_metatypes=[metatype]);
                   
         founds.sort(sort)          founds.sort(sort)
                   logging.debug("MPIWGProjects end: sorted by place: "+ metatype)
         return founds          return founds
           
   
Line 1700  class MPIWGProject(CatalogAware,Folder): Line 302  class MPIWGProject(CatalogAware,Folder):
             pubSplit=pubSplit.replace("</p>","")              pubSplit=pubSplit.replace("</p>","")
             self.addPublication(pubSplit)              self.addPublication(pubSplit)
   
           setattr(self,"WEB_related_pub_copied",True);
           
         if RESPONSE:          if RESPONSE:
             RESPONSE.redirect('managePublications')                  
               self.redirect(RESPONSE,'managePublications')
           
       def hasRelatedPublicationsOldVersion(self):
           """teste ob es related publications gibt"""
           
           ret = True;
           if (self.getContent('WEB_related_pub')==''):
               ret=False;  #nichts im alten feld
           logging.debug("webrel:"+repr(ret))
           if (getattr(self,'WEB_related_pub_copied',False)):
               ret=False; # alte daten sind schon kopiert worden
           
           logging.debug("webrel_copied:"+repr(ret))
           publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication']);
           
           if(len(publications)>0):
               ret=False; # es gibt publicationen in der neuen liste
         
           
           logging.debug("len(publ)"+repr(ret))
           
           return ret;
       
       def hasRelatedDigitalSources(self):
           """test ob es digital sources gibt"""
           
           
           ret = (self.getContent('xdata_11').lstrip().rstrip()=='')
               
         
         
           return not ret;
               
           
                   
           
     def copyImageToMargin(self,RESPONSE=None):        def copyImageToMargin(self,RESPONSE=None):  
Line 1744  class MPIWGProject(CatalogAware,Folder): Line 382  class MPIWGProject(CatalogAware,Folder):
                     imageCaptions.append("")                      imageCaptions.append("")
                                   
                       
   
           
           
           
           
         #eintragen:          #eintragen:
         for imageURL in imageURLs:          for imageURL in imageURLs:
             filename=imageURL.split("/")[-1]              filename=imageURL.split("/")[-1]
Line 1769  class MPIWGProject(CatalogAware,Folder): Line 402  class MPIWGProject(CatalogAware,Folder):
                 try:#absolute                  try:#absolute
                     data=urllib.urlopen(self.imageURL).read()                      data=urllib.urlopen(self.imageURL).read()
                 except:                  except:
                     zLOG.LOG("MPIWG Project",zLOG.ERROR,"can't open: %s"%url)                      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 1833  class MPIWGProject(CatalogAware,Folder): Line 467  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):
Line 1843  class MPIWGProject(CatalogAware,Folder): Line 531  class MPIWGProject(CatalogAware,Folder):
         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 1856  class MPIWGProject(CatalogAware,Folder): Line 557  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 1869  class MPIWGProject(CatalogAware,Folder): Line 619  class MPIWGProject(CatalogAware,Folder):
         else:          else:
             return getattr(publications[-1][1],'place',0)              return getattr(publications[-1][1],'place',0)
                   
     def deletePublication(self,id,RESPONSE=Nedione):      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):
               """delete Publication id"""
               self.manage_delObjects([id])
               self.ZCacheable_invalidate()
               if RESPONSE:
           
                   self.redirect(RESPONSE,'managePublications')
                 
       def deleteRelatedProject(self,id,RESPONSE=None):
         """delete Publication id"""          """delete Publication id"""
         self.manage_delObjects([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"""
Line 1905  class MPIWGProject(CatalogAware,Folder): Line 673  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=True):      def hasChildren(self,date=None,onlyActive=1,onlyArchived=1):
         """check if project has children"""          """check if project has children"""
           
         ct=self.getContexts(childs=self.getContent('xdata_05'),          ct=self.getContexts(childs=self.getContent('xdata_05'),
                                  depth=1,date=date,onlyActive=onlyActive)                                   depth=1,date=date,onlyActive=onlyActive)
                   
Line 1940  class MPIWGProject(CatalogAware,Folder): Line 713  class MPIWGProject(CatalogAware,Folder):
         obj.id=filename          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 2009  class MPIWGProject(CatalogAware,Folder): Line 783  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 2035  class MPIWGProject(CatalogAware,Folder): Line 831  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 2053  class MPIWGProject(CatalogAware,Folder): Line 850  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)
                           
                           
   
Line 2071  class MPIWGProject(CatalogAware,Folder): Line 868  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 2080  class MPIWGProject(CatalogAware,Folder): Line 877  class MPIWGProject(CatalogAware,Folder):
         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.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:
Line 2105  class MPIWGProject(CatalogAware,Folder): Line 903  class MPIWGProject(CatalogAware,Folder):
         """check if the project is still active, default is true, set to false is the project is accomplished"""          """check if the project is still active, default is true, set to false is the project is accomplished"""
         return getattr(self,'isActiveFlag',True)          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):      def setActiveFlag(self,status=True):
         """set the active flag"""          """set the active flag"""
         self.isActiveFlag=status          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 2150  class MPIWGProject(CatalogAware,Folder): Line 1065  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 getGetNeighbourhood(self,wordStr, length=100,tagging=True):  
         """finde umgebung um die worte in wordStr, zurueckgegeben wird eine Array mit den Umgebungen von Fundstellen der Worte  
         alle Tags werden entfernt, die Fundstellen werden mit <span class="found">XX</span> getaggt, die Umgebungen werden   
         case insensitive gesucht  
         @param wordStr: string mit Worten getrennt durch Leerzeichen, Phrasen sind mit " gekennzeichnet  
                         "eine phrase", "*"  bezeichnet wildcards und wird ignoriert"  
         @param length: optional, default wert 100, 2*length ist die groesse der Umgebung  
         @param tagging: optional default wert true, kein span tag wird erzweugt falls tag=false  
         """  
                   
         ret=[] # nimmt das Array auf, dass spaeter zurueckgegeben wird      def harvest_page(self,context=None,mode="normal"):
         ranges=[] #Array mit tupeln x,y wobei x die Position des Anfang und y des Endes der i-ten Umgebung angiebt          """seite fuer harvesting fuer die Projektsuche"""
                   
         def isInRanges(nr,length):          if not context:
             """test ob eine gegeben Position nr schon irgendwo in einer Umgebung ist, gibt den Index des ersten Wertes aus ranges zurueck,               context=self
             -1, wenn kein Treffer  
                           
             @param nr: Position die geprueft werden soll          if self.isActiveProject() and self.isActual():
             @param length: Laenge des Wortes das geprueft werden soll               templates = self.en.getHarvestCache()
             """  
             for x in ranges:  
                 if (x[0]<=nr) and (nr < (x[1]-length)):  
                     return ranges.index(x)  
             return -1  
                   
         # deal with phrases, in Phrasen werden die Leerzeichen durch "_" ersetzt.  
         def rep_empty(str):  
             x= re.sub(" ","_",str.group(0))  
             return re.sub("\"","",x)  
               
         wordStr=re.sub("\".*?\"", rep_empty,wordStr)#ersetze leerzeichen in " " durch "_" und loesche "  
           
         #deal with wildcards, for our purposes it is enough to delete the wildcard   
         wordStr=wordStr.replace("*","")  
           
         words=wordStr.split(" ")  
         #if not words is ListType:  
         #   words=[words]  
                           
         txt=self.harvest_page()               ext=getattr(self,"harvest_main",None)
         if not txt:               if ext:
             return ret                   rendered = getattr(self,ext.getId())()
         txt=re.sub("<.*?>", "", txt) # loesche alle Tags                   templates[self.absolute_url()]=rendered
         for word in words:                   transaction.commit()
             word=re.sub("_"," ",word) # ersetze zurueck "_" durch " "                   return rendered
             pos=0                   
   
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)    
                           
             n=txt.lower().count(word.lower()) # wie oft tritt das Wort auf               rendered = pt()
                templates[self.absolute_url()]=rendered
                transaction.commit()
                return rendered
                    
    
         
       def index_html(self,request=True,context=None):
           """show homepage"""
   
             for i in range(n):          bound_names={}
                 pos=txt.lower().find(word.lower(),pos)  
   
                 if pos > 0:          if not context:
                     x=max(0,pos-length)              context=self
                     y=min(len(txt),pos+length)          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"])
                                           
                     #is word already in one of the results  
                     nr=isInRanges(pos,len(word))  
                     if nr >=0:# word ist in einer schon gefunden Umgebung, dann vergroessere diese  
                         x=min(ranges[nr][0],x)  
                         y=max(ranges[nr][1],y)  
                               
                     str=txt[x:y]          request2=getattr(self,'REQUEST',None)
                                   
                     if nr >=0: # word ist in einer schon gefunden Umgebung          if request2 is not None:
                         ranges[nr]=(x,y) # neue Position der Umgebung              response = request2.response
               if not response.headers.has_key('content-type'):
                   response.setHeader('content-type', 'text/html')
   
                         ret[nr]=str # neue Umgebung          security = getSecurityManager()
                     else: # andernfalls neue Umgebung hinzufuegen          bound_names['user'] = security.getUser()
                         ranges.append((x,y))  
   
                         ret.append(str)          # Retrieve the value from the cache.
           keyset = None
           if self.ZCacheable_isCachingEnabled():
                                           
                     pos=pos+len(word)              # Prepare a cache key.
                 else:              keyset = {'here': self, 'params':request2['QUERY_STRING']}
                     break;  
                                   
         # now highlight everything                      result = self.ZCacheable_get(keywords=keyset)
         if tagging:  
             for x in range(len(ret)):  
                 for word in words:  
                     repl=re.compile(word,re.IGNORECASE)  
                     ret[x]=repl.sub(""" <span class="found">%s</span>"""%word.upper(),ret[x])  
   
         return ret              if result is not None:
                   # Got a cached value.
                   return result
                                                                   
     def harvest_page(self,context=None):          pt = getTemplate(self, "project_main")
         """seite fuer harvesting fuer die Projektsuche"""           # Execute the template in a new security context.
         if not context:          security.addContext(self)
             context=self  
                           
         if self.isActiveProject() and self.isActual():          try:
              ext=getattr(self,"harvest_main",None)              #logging.debug("index_html pt=%s"%repr(pt))
              if ext:              result = pt.pt_render(extra_context=bound_names)
                  return getattr(self,ext.getId())()              #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)
   
              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)                  return result
           finally:
               security.removeContext(self)
   
   
              return pt()  
                     
     def index_html(self,request=True,context=None):      def index_html_old(self,request=True,context=None):
         """show homepage"""          """show homepage"""
         if not context:          if not context:
             context=self              context=self
Line 2264  class MPIWGProject(CatalogAware,Folder): Line 1162  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 2292  class MPIWGProject(CatalogAware,Folder): Line 1191  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 2312  class MPIWGProject(CatalogAware,Folder): Line 1218  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 2367  class MPIWGProject(CatalogAware,Folder): Line 1276  class MPIWGProject(CatalogAware,Folder):
     if (text5=="<br>") or (text5=="<br/>"):      if (text5=="<br>") or (text5=="<br/>"):
         text5=""          text5=""
   
         return text5.encode('utf-8')          #logging.debug("getcontent: field=%s filter=%s -> %s"%(field,filter,repr(text5)))
           return unicodify(text5)
           #return utf8ify(text5) # return as utf-8 byte string
   
   
     def showImagesOfPage(self,imageUrl=None):      def showImagesOfPage(self,imageUrl=None):
         """show Images of project"""          """show Images of project"""
Line 2389  class MPIWGProject(CatalogAware,Folder): Line 1301  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 2398  class MPIWGProject(CatalogAware,Folder): Line 1311  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 management screens','edit')      security.declareProtected('View management screens','editOldVersion')
     def edit(self,western=None):      def editOldVersion(self,western=None):
         """Edit pages"""          """Edit pages"""
         if western:          if western:
             self.REQUEST.RESPONSE.setCookie("MP_debug_code","western",path="/")              self.REQUEST.RESPONSE.setCookie("MP_debug_code","western",path="/")
Line 2428  class MPIWGProject(CatalogAware,Folder): Line 1341  class MPIWGProject(CatalogAware,Folder):
         else:          else:
             return style                  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 2438  class MPIWGProject(CatalogAware,Folder): Line 1401  class MPIWGProject(CatalogAware,Folder):
             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          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 2454  class MPIWGProject(CatalogAware,Folder): Line 1417  class MPIWGProject(CatalogAware,Folder):
             <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.WEB_project_description[0]              """%self.WEB_project_description[0]
                   
         return """          return """
Line 2463  class MPIWGProject(CatalogAware,Folder): Line 1426  class MPIWGProject(CatalogAware,Folder):
             <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')
                   
                   
Line 2474  class MPIWGProject(CatalogAware,Folder): Line 1437  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):
Line 2487  class MPIWGProject(CatalogAware,Folder): Line 1558  class MPIWGProject(CatalogAware,Folder):
                 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'):          if self.REQUEST.has_key('historicalNames'):
             self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))              self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))
                   
Line 2494  class MPIWGProject(CatalogAware,Folder): Line 1575  class MPIWGProject(CatalogAware,Folder):
             self.setActiveFlag(True)              self.setActiveFlag(True)
         else:          else:
             self.setActiveFlag(False)              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
           
           self.reindex_object()
         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 2522  class MPIWGProject(CatalogAware,Folder): Line 1626  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 2559  class MPIWGProject(CatalogAware,Folder): Line 1663  class MPIWGProject(CatalogAware,Folder):
         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"""
           if not identifiedNames:
               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)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)
         return pt()          return pt(identifiedNames=identifiedNames)
   
     security.declareProtected('View management screens','editMPIWGBasisForm')      security.declareProtected('View management screens','editMPIWGBasisForm')
     def editMPIWGBasisForm(self):      def editMPIWGBasisForm(self):
Line 2605  class MPIWGProject(CatalogAware,Folder): Line 1715  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.68  
changed lines
  Added in v.1.47.2.131

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