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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.47.2.54 and 1.47.2.81

version 1.47.2.54, 2006/07/14 09:14:17 version 1.47.2.81, 2008/06/19 11:49:34
Line 2 Line 2
 for organizing and maintaining the different project pages  for organizing and maintaining the different project pages
   
 """  """
 #TODO: mechanismus fur links to personen ueberarbeiten, da jetzt alle e_mails als members auftauchen unabhaengig vom status publish_the_data  #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: 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  #TODO: in einzelnen projecte steht als pfad auf die bilder noch wwwneu statt www
   
Line 19  import string Line 19  import string
 import re  import re
 import os  import os
 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
Line 33  from Ft.Xml.XPath import Evaluate Line 33  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 updatePersonalWWW
   import MPIWGStaff
   
 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']  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']  checkFields = ['xdata_01']
   
   #ersetzt logging
   def logger(txt,method,txt2):
       """logging""" 
       logging.info(txt+ txt2)
   
 def getTextFromNode(nodename):  def getTextFromNode(nodename):
     nodelist=nodename.childNodes      nodelist=nodename.childNodes
Line 47  def getTextFromNode(nodename): Line 54  def getTextFromNode(nodename):
            rc = rc + node.data             rc = rc + node.data
     return rc      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):  def sortF(x,y):
     try:      try:
         return cmp(x[1],y[1])          return cmp(x[1],y[1])
Line 79  def sortI(x,y): Line 110  def sortI(x,y):
     except:      except:
         return cmp(x[1],y[1])          return cmp(x[1],y[1])
   
   
   def unicodify(str):
       """decode str (utf-8 or latin-1 representation) into unicode object"""
       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 utf8ify(str):
       """encode unicode object or string into byte string in utf-8 representation"""
       if not str:
           return ""
       if type(str) is StringType:
           return str
       else:
           return str.encode('utf-8')
   
   
 class MPIWGLink(SimpleItem):  class MPIWGLink(SimpleItem):
     """create a symbolic link to another page"""      """create a symbolic link to another page"""
   
Line 118  class MPIWGLink(SimpleItem): Line 172  class MPIWGLink(SimpleItem):
         return obj          return obj
   
     def getWeight(self):      def getWeight(self):
         if self.linkWeight and linkWeight!="":          if self.linkWeight and self.linkWeight!="":
             return self.linkWeight              return self.linkWeight
         else:          else:
             return self.getObj().weight              return self.getObj().weight
   
     manage_options=SimpleItem.manage_options+(      manage_options=(
         {'label':'main config','action':'changeLinkForm'},          {'label':'main config','action':'changeLinkForm'},
         )          )+SimpleItem.manage_options
   
   
     def changeLinkForm(self):      def changeLinkForm(self):
Line 142  class MPIWGLink(SimpleItem): Line 196  class MPIWGLink(SimpleItem):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage')              RESPONSE.redirect('manage')
   
     def index_html(self):      def index_html(self,**argv):
         """index"""          """index"""
                   
   
   
           try:
         return self.getObj().pt_render(extra_context={'here':self})          return self.getObj().pt_render(extra_context={'here':self})
           except:
               self.REQUEST.RESPONSE.redirect(self.getObj().absolute_url())
                                          
                                                                                 
   
 def manage_addMPIWGLinkForm(self):  def manage_addMPIWGLinkForm(self):
Line 214  def manage_addMPIWGTemplateForm(self): Line 274  def manage_addMPIWGTemplateForm(self):
 from urllib import quote  from urllib import quote
   
   
 def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):  def manage_addMPIWGTemplate(self, MPIWGType,id, text="",title=None,weight=0,REQUEST=None):
     "Add a Page Template with optional file content."      "Add a Page Template with optional file content."
     if type(MPIWGType)==StringType:      if type(MPIWGType)==StringType:
         MPIWGTypes=[MPIWGType]          MPIWGTypes=[MPIWGType]
Line 257  def manage_addMPIWGTemplate(self, MPIWGT Line 317  def manage_addMPIWGTemplate(self, MPIWGT
   
           
 class MPIWGRoot(ZSQLExtendFolder):  class MPIWGRoot(ZSQLExtendFolder):
     """Stammordner für den Web-Server"""      """Stammordner fuer den Web-Server"""
   
     fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',      fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',
              'xdata_03':'Historical Persons','xdata_04':'Time period',               'xdata_03':'Historical Persons','xdata_04':'Time period',
Line 270  class MPIWGRoot(ZSQLExtendFolder): Line 330  class MPIWGRoot(ZSQLExtendFolder):
     folders=['MPIWGProject','Folder','ECHO_Navigation']      folders=['MPIWGProject','Folder','ECHO_Navigation']
     meta_type='MPIWGRoot'      meta_type='MPIWGRoot'
   
       
       def harvestProjects(self):
           """harvest"""
           folder="/tmp"
           try:
               os.mkdir("/tmp/harvest_MPIWG")
           except:
               pass
           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):      def decode(self,str):
         """decoder"""          """decoder"""
         if not str:          if not str:
Line 280  class MPIWGRoot(ZSQLExtendFolder): Line 358  class MPIWGRoot(ZSQLExtendFolder):
         except:          except:
         return str.decode('latin-1')          return str.decode('latin-1')
         else:          else:
               
             return str              return str
   
   
       def getat(self,array,idx=0,default=None):
           """return array element idx or default (but no exception)"""
           if len(array) <= idx:
               return default
           else:
               return array[idx]
           
   
       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):      def versionHeaderEN(self):
         """version header text"""          """version header text"""
                   
Line 354  class MPIWGRoot(ZSQLExtendFolder): Line 468  class MPIWGRoot(ZSQLExtendFolder):
             else:              else:
                 return False                  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):      def subNav(self,obj):
         """return subnav elemente"""          """return subnav elemente"""
         def sortWeight(x,y):          def sortWeight(x,y):
Line 368  class MPIWGRoot(ZSQLExtendFolder): Line 498  class MPIWGRoot(ZSQLExtendFolder):
   
                   
         #suche die zweite ebene          #suche die zweite ebene
           
         if not obj.aq_parent.getId() in ['de','en']:          if not obj.aq_parent.getId() in ['de','en']:
             obj=obj.aq_parent              obj=obj.aq_parent
                           
         while not self.ZopeFind(self,obj_ids=[obj.getId()]):          while not self.ZopeFind(self,obj_ids=[obj.getId()]):
             obj=obj.aq_parent              obj=obj.aq_parent
                   
         
         if hasattr(self,obj.getId()):          if hasattr(self,obj.getId()):
                           
             subs=self.ZopeFind(getattr(self,obj.getId()),obj_metatypes=['MPIWGTemplate','MPIWGLink'])              subs=self.ZopeFind(getattr(self,obj.getId()),obj_metatypes=['MPIWGTemplate','MPIWGLink'])
Line 394  class MPIWGRoot(ZSQLExtendFolder): Line 526  class MPIWGRoot(ZSQLExtendFolder):
                 return True                  return True
         return False          return False
                   
       def getSection(self):
           """returns the current section name"""
           root = self.absolute_url()
           url = self.REQUEST['URL']
           if not url:
               return None
           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):      def upDateSQL(self,fileName):
         """updates SQL databases using fm.jar"""          """updates SQL databases using fm.jar"""
         fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')          fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')
         xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)          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))          logger("MPIWG Web",logging.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()          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)          logger("MPIWG Web",logging.INFO,"result convert: %s"%ret)
         return 1          return 1
           
     def patchProjects(self,RESPONSE):      def patchProjects(self,RESPONSE):
Line 502  class MPIWGRoot(ZSQLExtendFolder): Line 660  class MPIWGRoot(ZSQLExtendFolder):
         self.id=id          self.id=id
         self.title=title          self.title=title
   
     def urlQuote(self,str):      def removeStopWords(self,xo):
         """quote"""          """remove stop words from xo"""
         return urllib.quote(str)          if not hasattr(self,'_v_stopWords'):
               self._v_stopWords=self.stopwords_en.data.split("\n")
   
     def urlUnQuote(self,str):          x=str(xo)
         """quote"""  
         return urllib.unquote(str)  
           
     def harvestHistoricalPersons(self):          strx=x.split(" ")
         """erstelle liste aller erwaehnten actors"""  
   
         def normalize(str):          for tmp in strx:
             """loesche fuhrendes space"""  
             if (len(str)>1) and (str[0]==" "):  
                 ret=str[1:]  
             else:  
                 ret=str  
             return ret  
           
         list={}  
         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])  
           
         for project in projects:  
             lg=len(project[1].xdata_03[0])-1  
   
             if (lg>1) and (project[1].xdata_03[0][lg]==";"):  
                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]  
   
               if tmp.lower() in self._v_stopWords:
                   del strx[strx.index(tmp)]
                       
           return " ".join(strx)
             
       def urlQuote(self,str):
           """quote"""
           return urllib.quote(str)
                                   
             try:      def urlUnQuote(self,str):
                 if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;          """quote"""
                     for person in project[1].xdata_03[0].split(";"):          return urllib.unquote(str)
                         personNormal=normalize(person)  
                         if personNormal in list.keys():  
                             list[urllib.quote(personNormal)][1].append(project[1])  
                         else:  
                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])  
                 else: #guess , is sepeator  
                     for person in project[1].xdata_03[0].split(","):  
                         personNormal=normalize(person)  
                         if urllib.quote(personNormal) in list.keys():  
                             list[urllib.quote(personNormal)][1].append(project[1])  
                         else:  
                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])  
   
             except:  
                 zLOG.LOG("MPIWG Web (harvestHistoricalPerson)",zLOG.ERROR,"cannot analyize: %s"%repr(project))  
   
                   
         return list  
   
     def storeHistoricalPersons(self,RESPONSE=None):  
         """store persons"""  
         self.personDict={}  
         personDict=self.harvestHistoricalPersons()  
         for person in personDict.keys():  
             for project in personDict[person][1]:  
                 if person in self.personDict.keys():  
                     self.personDict[person][1].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))  
                 else:  
                     self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])  
   
         if RESPONSE is not None:  
             RESPONSE.redirect("showHistoricalPersons")  
               
   
     def getPersonDict(self,name):  
         """name von dict"""  
   
         try:  
             return self.personDict[name][0].encode('utf-8')  
         except:  
             return self.personDict[name][0]  
             return self.personDict[name][0].decode('latin-1').encode('utf-8')  
           
   
     def showHistoricalPersons(self):  
         """show persons"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showHistoricalPersons')).__of__(self)  
         return pt()  
   
                   
     def editHistoricalPersonsForm(self):  
         """edit historical persons for consistency"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalPersonsForm')).__of__(self)  
         return pt()  
   
     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry, date=None):      def getProjectsByFieldContent(self,fieldName,fieldContentsEntry, date=None):
         """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""          """gib alle Projekte aus mit Value von field mit fieldName enthaelt ein Element der Liste fieldContents"""
         def sort(x,y):          def sort(x,y):
                 return cmp(x.WEB_title[0],y.WEB_title[0])                  return cmp(x.WEB_title[0],y.WEB_title[0])
   
Line 633  class MPIWGRoot(ZSQLExtendFolder): Line 728  class MPIWGRoot(ZSQLExtendFolder):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              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):      def getContexts(self,childs=None,parents=None,depth=None,date=None,onlyActive=True):
         """childs alle childs, alle parents"""          """childs alle childs, alle parents"""
Line 700  class MPIWGRoot(ZSQLExtendFolder): Line 783  class MPIWGRoot(ZSQLExtendFolder):
                   
         if sort=="int":          if sort=="int":
             ret.sort(sortI)              ret.sort(sortI)
           elif sort=="stopWords":
    
               ret.sort(sortStopWords(self))
               
         else:          else:
             ret.sort(sortF)              ret.sort(sortF)
                   
Line 716  class MPIWGRoot(ZSQLExtendFolder): Line 803  class MPIWGRoot(ZSQLExtendFolder):
           
                   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Update personal homepages','action':'updateHomepages'},          {'label':'Update personal homepages','action':'updatePersonalwww_html'},
         {'label':'Reindex catalogs','action':'reindexCatalogs'},          {'label':'Reindex catalogs','action':'reindexCatalogs'},
         {'label':'Main config','action':'changeMPIWGRootForm'},          {'label':'Main config','action':'changeMPIWGRootForm'},
           {'label':'add e-mails','action':'showNewDBEntries'},
           {'label':'update the institutsbibliography','action':'updateInstitutsbiliography'},
         #{'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},          #{'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
         #{'label':'Store Historical Persons','action':'storeHistoricalPersons'},          #{'label':'Store Historical Persons','action':'storeHistoricalPersons'},
         )          )
           
     def importNamesForm(self):  
         """Form"""  
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGNamesForm.zpt')).__of__(self)  
         return pt()  
   
     def importNames(self,fileupload,folderName,RESPONSE=None):  
         """import komma-sep list email,lastName,firstName"""  
         project=getattr(self,folderName)  
         load=fileupload.read()  
           
         for line in load.split('\r'):  
               
               
             splitted=line.split(",")  
            # print splitted  
           
             if not (splitted[0]==""):  
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])  
                   
                 try:  
                     project._setObject(splitted[0],newObj)  
                     #print "done:",splitted[0]  
                 except:  
                     zLOG.LOG("MPIWG Web (importNames)",zLOG.INFO,"cannot import: %s"%splitted[0])  
   
                       
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def updatePublicationDB(self,personId=None):      def updatePublicationDB(self,personId=None):
         """updates the publication db, i.e. copy year into the main table"""          """updates the publication db, i.e. copy year and type into the main table"""
                   
         if personId:          if personId:
             founds = self.ZSQLInlineSearch(_table="publications",id_main=personId)              founds = self.ZSQLInlineSearch(_table="publications",key_main=personId)
         else:          else:
             founds = self.ZSQLInlineSearch(_table="publications")              founds = self.ZSQLInlineSearch(_table="publications")
                           
Line 775  class MPIWGRoot(ZSQLExtendFolder): Line 836  class MPIWGRoot(ZSQLExtendFolder):
                                           
         return True                  return True        
                   
     def updateHomepages(self,RESPONSE=None):      def showNewDBEntries(self):
         """ update"""          """zeige neue Eintraege in der Datenbank ohne e-mail adressen bzw. fuer die noch kein Object angelegt wurde"""
                   
         RESPONSE.setHeader('Content-type', 'text/html')          qstr="select * from personal_www where web_object_created='no' and not key=''"
         RESPONSE.write("<html><body>\n")          res=self.ZSQLQuery(qstr)
         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")          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showNewDBEntries.zpt')).__of__(self)
           return pt(newEntries=res)
                   
       def createNewStaffObjects(self,RESPONSE):
           """create new staff object"""
                   
         memberFolder=getattr(self,'members')          memberFolder=getattr(self,'members')
         members=memberFolder.ZopeFind(memberFolder,obj_metatypes=["MPIWGStaff"])          args=self.REQUEST.form
           arg_k=args.keys()
           arg_k.remove("submit")
           ret=""
           for key in arg_k:
               k=self.urlUnQuote(key)
             
               qstr="select * from personal_www where key=%s"%self.ZSQLQuote(k)
               res=self.ZSQLQuery(qstr)[0]
               if args[key]!="": #email-adresse wurde eingetragen
                   #create the object
                   e_mail=args[key]
                   try:
                       newObj=MPIWGStaff.MPIWGStaff(e_mail,res.last_name,res.first_name,k)
                       memberFolder._setObject(e_mail,newObj)
                       obj=getattr(memberFolder,e_mail)
                       obj.reindex_object()
                       ret+="Created %s \n"%e_mail
                       created=True
                   except:
                       msg="Cannot create new user %s (%s %s)"%(e_mail,sys.exc_info()[0],sys.exc_info()[1])
                       logging.error(msg)
                       ret+=msg+"\n"
                       created=False
                   
                   if created:
                       qstr="update personal_www set web_object_created='yes',e_mail='%s@mpiwg-berlin.mpg.de' where key=%s"%(e_mail,self.ZSQLQuote(k))
                       self.ZSQLQuery(qstr)
           
           return ret
                      
                   
         memberList=[x[0] for x in members]      def generateNewPersonEntry(self,data):
         #print dom          """generate a new person entry for data, neue personen werden zunaechst nur in der datenbank angelegt """
         #ctx=Context(dom,processorNss={EMPTY_NAMESPACE:'http://www.filemaker.com/fmpdsoresult'})          
         # Evaluate(u".//dn:ROW",contextNode=dom,explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})          #memberFolder=getattr(self,'members')
         #print dom.xpath(u'.//dn:ROW',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})          #create the object
         for row in dom.xpath(u'.//dn:ROW',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'}):          
           #        try:
             username=getTextFromNode(row.xpath('./dn:username',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  #            newObj=MPIWGStaff.MPIWGStaff(urllib.quote(data['key']),data['last_name'].encode('utf-8'),data['first_name'].encode('utf-8')) 
             id=getTextFromNode(row.xpath('./dn:ID',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  #            memberFolder._setObject(urllib.quote(data['key']),newObj)
             name=getTextFromNode(row.xpath('./dn:Name',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  #        except:
             vorname=getTextFromNode(row.xpath('./dn:Vorname',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])  #            return False, "Cannot create new user %s (%s %s)"%(data['key'],sys.exc_info()[0],sys.exc_info()[1])
             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:  
                 txt_p=getTextFromNode(cw[0])  
             else:  
                 txt_p=""  
                
             project=getattr(self,'members')  
               
             if not (username in memberList):#neuer eintrag  
                   
                 try:  
                     newObj=MPIWGStaff.MPIWGStaff(str(username),name.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:  
                 RESPONSE.write("<p>update:%s</p>\n"%username.encode('utf-8'))  
                   
                 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)          #create the new entry in the database
                                   
                 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,          result,msg=MPIWGStaff.createNewDBEntry(self,data['publish_the_data'],data['key'],data['last_name'],
                                           vorname,username,title,position,e_mail,                                    data['first_name'],data['title'],data['status'],"",
                                           e_mail_p,date_from,date_to,                                    "",data['date_from'],data['date_to'],
                                           abteilung,heimat_inst,funded_by,                                    data['department'],data['home_inst'],data['funded_by'],
                                           e_mail2,txt,txt_p,stay_at_mpiwg)                                    data['e_mail2'],data['current_work'],"yes",data['date_stay_at_mpiwg'],data['group'],"no",data['current_work'])
                     if not ret[0]:  
   
                             RESPONSE.write("<p>Error: %s</p>\n"%repr(ret[1]))          return result,msg
                     else:  
                         RESPONSE.write("<p>New: %s</p>\n"%repr(ret[1]))  
   
         #TODO: reindexCatlogs and updatePublications wieder einbaue      def updatePersonEntry(self,data,ignoreEntries=[]):
         #self.reindexCatalogs(RESPONSE)          """update an person entry from data. but ignore all fields in ignore Entries"""
           
         #self.updatePublicationDB()          ignoreEntries.append('current_work') # TODO:updatecurrent work
     
         #self.ZSQLResetConnection()          if data['date_to']=="": # wenn date_to leer
         RESPONSE.write("<h2>Done</h2></body></html>")               data['date_to']="date_none"
                                         
         return True          if data['date_from']=="": # wenn date_fromleer
                data['date_from']="date_none"
           msg=""
             
     def reindexCatalogs(self,RESPONSE=None):  
         """reindex members and project catalog"""  
                   
           #eintragen
                   
         try:          columns=data.keys()
             self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])          for x in ignoreEntries:
             self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])              logging.info("ign rem: %s"%x)
               try: #falls in ignore entries felder sind, die nicht in columns sind, fange den fehler ab
                columns.remove(x)
         except:          except:
             zLOG.LOG("MPIWG Root (updatehomepage)",zLOG.WARNING," %s %s"%sys.exc_info()[:2])                  pass
                           
                   
           insert=[]
           for key in columns:
               if data[key]=="date_none": # date_none eintrag wird zu null uebersetzt
                   insert.append('%s=null'%key)
               else:
                   insert.append(""" "%s"=%s"""%(key,self.ZSQLQuote(data[key])))
               
           insertStr=",".join(insert)
           queryStr="update personal_www SET %s where key='%s'"%(insertStr,data['key'])
           self.ZSQLQuery("SET DATESTYLE TO 'German'")
           self.ZSQLQuery(queryStr)
          
           #currentwork
           #if not (txt==""):
           #    queryStr="INSERT INTO current_work (id_main,current,publish) VALUES ('%s','%s','%s')"%(id,txt,txt_p)
           #
           #    self.ZSQLQuery(queryStr)
           
           return True,msg
                   
                         
         if RESPONSE:      def updatePersonalwww_doIt(self):
             RESPONSE.redirect('manage_main')          """do the update"""
           args=self.REQUEST.form
           resultSet=self.REQUEST.SESSION['personal_www']['resultSet']
           news=self.REQUEST.SESSION['personal_www']['news']
           conflicts=self.REQUEST.SESSION['personal_www']['conflicts']
           ret="<html><body>"
           # generate the new entry
         
           if news and (len(news)>0):
               ret+="<h2>Hinzugef&uuml;gt</h2>"
               ret+="<p>Neueintr&auml;ge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"
               ret+="<ul>"
           for new in news:
         
               if args.has_key(self.urlQuote(new.encode('utf-8'))): # entry was selected
                   result,msg=self.generateNewPersonEntry(resultSet[new])
                   if not result:
                       logging.error("Error (generateNewPersonEntry) %s"%msg)
                       ret+="<li>ERROR: %s %s"%(new.encode('utf-8'),msg)
                   else:
                       ret+="<li>OK: %s"%(new.encode('utf-8'))
           if news and (len(news)>0):
               ret+="<p>Neueintr&auml;ge erscheinen erst auf der Homepage, wenn ihnen eine e-mail Adresse zugeordnet wurde.</p>"
               ret+="</ul>"     
           
           # update
   
           if len(conflicts.keys())>0:
               ret+="<h2>&Auml;nderung des Benutzers &uuml;bernehmen</h2>"
               ret+="<p>Wenn n&ouml;tig in Filemaker-db &auml;ndern:</p>"
               
           # konflicte   
           for conflict in conflicts.keys():
               ignoreEntries=[]
               displayIgnored=[]
               for cf in conflicts[conflict]:
                   if args[conflict.encode('utf-8')+'_'+cf[0]]=="stored": #use the stored one
                       ignoreEntries.append(cf[0])  #so ignore field cf[0]       
                       displayIgnored.append(cf)
               if len(displayIgnored)>0:
                   ret+="<h3>%s</h3>"%conflict.encode('utf-8')
                   
                   ret+="<table border='1'>"
                   for iE in displayIgnored:
                       ret+="<tr><td>%s</td><td>%s</td><td>%s</td>"%(iE[0].encode('utf-8'),iE[1].encode('utf-8'),iE[2].encode('utf-8'))
                   ret+="</tabel>"
                   
               self.updatePersonEntry(resultSet[conflict],ignoreEntries=ignoreEntries)
            
            # rest
           cl=list(conflicts.keys())
           
           for key in resultSet.keys():
                if key not in cl:
                    self.updatePersonEntry(resultSet[key])
           return ret+"</body></html>"
                   
                   
     def updateHomepages_old(self,RESPONSE):      def updateInstitutsbiliography(self):
         """lege members an, alte version vollstaendige kopie aller fm-dateien per fm.jar"""          """update the Institutsbibliogrpahy"""
         self.upDateSQL('personalwww.xml')          self.upDateSQL('personalwww.xml')
         founds=self.ZSQLInlineSearch(_table='personal_www',publish_the_data='yes')          return "<html><body>DONE</body></html>"
         project=getattr(self,'members')  
         for found in founds:  
                           
             if not (found.e_mail==""):  
                 newObj=MPIWGStaff.MPIWGStaff(found.username,found.name,found.vorname)  
                                   
                 try:      def updatePersonalwww_html(self):
                     project._setObject(found.username,newObj)          """update form for the homepages web form"""
                     RESPONSE.write("<p>new:%s</p>\n"%found.username)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','updatePersonalwww.zpt')).__of__(self)
                 except:          return pt()
                     RESPONSE.write("<p>old:%s (%s,%s)</p>\n"%(found.username,found.name,found.vorname))  
   
       def updatePersonalwww(self,uploadfile):
           """update personalwww
           @param uploadfile: file handle auf das file
           """
           dsn=self.getConnectionObj().connection_string
           #dsn="dbname=personalwww"
           resultSet=updatePersonalWWW.importFMPXML(uploadfile)
           news,conflicts=updatePersonalWWW.checkImport(dsn, resultSet)
   
           self.REQUEST.SESSION['personal_www']={}
           self.REQUEST.SESSION['personal_www']['resultSet']=resultSet
           self.REQUEST.SESSION['personal_www']['news']=news
           self.REQUEST.SESSION['personal_www']['conflicts']=conflicts
           
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','updatePersonalwww_check.zpt')).__of__(self)
           return pt()
                                   
   
         #delete non existing  
   
       def reindexCatalogs(self,RESPONSE=None):
           """reindex members and project catalog"""
   
         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:          try:
             self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])              
         except:  
             pass  
         self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])          self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
           except:
               logger("MPIWG Root (updatehomepage)",logging.WARNING," %s %s"%sys.exc_info()[:2])
           
         self.updatePublicationDB()   
                         
         if RESPONSE is not None:      
           
              
           if RESPONSE:
             RESPONSE.redirect('manage_main')              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):      def getAllMembers(self):
         #ret=[]          #ret=[]
Line 997  class MPIWGRoot(ZSQLExtendFolder): Line 1086  class MPIWGRoot(ZSQLExtendFolder):
             return entry              return entry
   
   
     def getTree(self,date=None,onlyActive=None):      def getTree(self,dep=None,date=None,onlyActive=0,onlyArchived=0):
         """generate Tree from project list"""          """generate Tree from project list
           als Liste, jeder Eintrag ist ein Tupel ,(Tiefe, ProjektNummer,ProjektObject
           onlyActive = 0  : alle Projekte
           onlyActive = 1 : nur active Projekte
           onlyActive = 2: nur inactive Projekte
           
           onlyArchived=0: alle Projekte
           onlyArchived= 1 : nur aktuelle Projekte
           onlyArchived = 2: nur archivierte Projekte
           """
   
           returnListTmp=[]
         returnList=[]          returnList=[]
           
         for project in self.getProjectFields('xdata_05',sort="int",date=date): # get Projects sorted by xdata_05          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              for idNr in project[1].split(";"): # more than one number
Line 1012  class MPIWGRoot(ZSQLExtendFolder): Line 1112  class MPIWGRoot(ZSQLExtendFolder):
                     title=[project[0].getContent('WEB_title')]                      title=[project[0].getContent('WEB_title')]
                     #print title                      #print title
                                           
                     if idNr[0]=="x": # kompatibilitŠt mit alter Konvention, x vor der Nummer macht project inactive                      if idNr[0]=="x": # kompatibilitaet mit alter Konvention, x vor der Nummer macht project inactive
                         project[0].setActiveFlag(False)                          project[0].setActiveFlag(False)
                                         
                     if onlyActive and project[0].isActiveProject(): #nur active projekte                      if (not dep) or (idNr[0]==dep): #falls dep gesetzt ist nur dieses hinzufuegen.
                        returnList.append((depth,nr,title,project[0]))  
                     elif not onlyActive:  
                       returnList.append((depth,nr,title,project[0]))  
         return returnList  
   
     def formatElementsAsList(self,elements):  
         """formatiere tree als liste"""  
                   
         actualDepth=0                          if (onlyActive==0):
         ret=""                              returnListTmp.append((depth,nr,title,project[0]))
         for element in elements:                          elif (onlyActive==1) and project[0].isActiveProject(): #nur active projekte
             if (element[0]>actualDepth):                              returnListTmp.append((depth,nr,title,project[0]))
                 #fuege soviele ul ein wie unterschied in tiefe                          elif (onlyActive==2) and (not project[0].isActiveProject()): #nur active projekte
                 if element[0]==1:                              returnListTmp.append((depth,nr,title,project[0]))
                     ret+="""<div class="dept">\n<ul class="liste">\n"""                     
                 else:                     
                     for i in range(element[0]-actualDepth):          #filter jetzt die Liste nach Archived oder nicht
                         if i>0:          for entry in returnListTmp:
                             ret+="<li>"                      if (onlyArchived==0):
                         ret+="""<ul class="liste">\n"""                              returnList.append(entry)
                       elif (onlyArchived==1) and (not entry[3].isArchivedProject()): #nur active projekte
                 actualDepth=element[0]                              returnList.append(entry)
                                       elif (onlyArchived==2) and (entry[3].isArchivedProject()): #nur active projekte
             elif (element[0]<actualDepth):                              returnList.append(entry)
                 #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')  
                 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 returnList
             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):      def changePosition(self,treeId,select,RESPONSE=None):
Line 1131  class MPIWGRoot(ZSQLExtendFolder): Line 1175  class MPIWGRoot(ZSQLExtendFolder):
         """change the complete tree"""          """change the complete tree"""
         form=self.REQUEST.form          form=self.REQUEST.form
         hashList={}          hashList={}
         fields=self.getTree()          onlyArchived=int(form.get("onlyArchived",0))
           onlyActive=int(form.get("onlyActive",0))
           
   
           fields=self.getTree(onlyArchived=onlyArchived,onlyActive=onlyActive)
                   
         for idNr in form.keys():          logging.info("GOT TREE!----------------------------------------------------")
           for field in form.keys():
                           
             splitted=idNr.split('_')              splitted=field.split('_')
               if (len(splitted)>1) and (splitted[1]=="runningNumber"): #feld hat die Form Nummer_name und runnignNumber
                           
             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                  nr=int(splitted[0]) # nummer des Datensatzes
                   currentEntry = fields[nr]
                                       
                     fields[int(splitted[0])][3].setActiveFlag(True)                  if form.has_key(str(nr)+'_active'): # active flag is set
                       fields[nr][3].setActiveFlag(True)
                 else:                  else:
                       fields[nr][3].setActiveFlag(False)
                       
                   #nummer hat sich geŠndert
                   
                   entryChanged = False;
                   
                   
                   if not (fields[nr][3].xdata_05==form[str(nr)+'_number']):
                       logging.info("Changed!Number+++++++++++++++++++++++++++++++++")
                       fields[nr][3].xdata_05=form[str(nr)+'_number']
                       entryChanged = True
                       
                   #completed har sich geaendert
                               
                   if not (fields[nr][3].getCompletedAt()==fields[nr][3].transformDate(form[str(nr)+'_completed'])):
                       fields[nr][3].setCompletedAt(form[str(nr)+'_completed'])
                       logging.info("Changed!Completed+++++++++++++++++++++++++++++++++")
                       entryChanged = True
                   
                   
                   if entryChanged:
                       logging.info("Changed!+++++++++++++++++++++++++++++++++")
                       fields[nr][3].copyObjectToArchive()
                                       
                     fields[int(splitted[0])][3].setActiveFlag(False)  
                                           
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('showTree')              RESPONSE.redirect('showTree')
Line 1195  class MPIWGRoot(ZSQLExtendFolder): Line 1264  class MPIWGRoot(ZSQLExtendFolder):
         return string.join(ret,";")          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:
                      logging.error("search publ %s:"%member[0].getObject().isPublished())
                   if member and (member[0].getObject().isPublished()):
                       if person =="Otto Sibum" : person="H. Otto Sibum"
                       if person =="Norton Wise" : person="M. Norton Wise"
                       
                       #memberlist.append("<a href=%s >%s</a>"%(member[0].absolute_url,person.encode('utf-8')))
                       memberlist.append((person, member[0].getObject().getId()))
                   else:
                       #memberlist.append("%s"%person.encode('utf-8'))
                       memberlist.append((person,None))
           return memberlist
                            
     def getUrlFromPerson(self,list):      def getUrlFromPerson(self,list):
         """get urls to person list"""          """get urls to person list"""
         ret=[]          ret=[]
Line 1221  class MPIWGRoot(ZSQLExtendFolder): Line 1324  class MPIWGRoot(ZSQLExtendFolder):
                     if person =="Otto Sibum" : person="H. Otto Sibum"                      if person =="Otto Sibum" : person="H. Otto Sibum"
                     if person =="Norton Wise" : person="M. Norton Wise"                      if person =="Norton Wise" : person="M. Norton Wise"
                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))                      #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
                     ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url+"/index.html",person))              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:                  else:
                     #ret.append("%s"%person.encode('utf-8'))                      #ret.append("%s"%person.encode('utf-8'))
                     ret.append("%s"%person)                      ret.append("%s"%person)
Line 1239  class MPIWGRoot(ZSQLExtendFolder): Line 1346  class MPIWGRoot(ZSQLExtendFolder):
                           
         return ret          return ret
   
     def getProjectsOfMember(self,name=None,email=None,date=None):      def getProjectsOfMember(self,name=None,key=None,date=None,onlyArchived=1):
         """get project of a member"""          """get projects of a member
           @param name: (optional)Vorname + Nachname
           @param key: (optional) Key zur Idenfikation des Benutzer
           @param date: (optional) Version die zum Zeitpunkt date gueltig war
           @param onlyArchived: 
           onlyArchived=0: alle Projekte
           onlyArchived= 1 : nur aktuelle Projekte
           onlyArchived = 2: nur archivierte Projekte
           """
           # TODO: Die ganze Loesung
         def sortP(x,y):          def sortP(x,y):
             """sort by sorting number"""              """sort by sorting number"""
             #print x.xdata_05,y.xdata_05  
             return cmp(x.WEB_title,y.WEB_title)              return cmp(x.WEB_title,y.WEB_title)
                   
          
         ret=[]          ret=[]
         splitNeu=[]          if key:
         if email:    
               members=self.MembersCatalog({'getKey':key})
               if len(members)==0:
                   return ret          
               splitted =  [members[0].lastName,members[0].firstName]
           
           elif name:
               
               splitted=name.split(",")
           else:
               return ret # name oder key mussen definiert sein
                           
             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]+"\'"]          splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]
                   
         #for s in splitted:  
         #    splitNeu.append("\""+s+"\"")  
         search=string.join(splitNeu,' AND ')          search=string.join(splitNeu,' AND ')
                   
         proj=self.ProjectCatalog({'xdata_01':search})          proj=self.ProjectCatalog({'xdata_01':search})
Line 1269  class MPIWGRoot(ZSQLExtendFolder): Line 1386  class MPIWGRoot(ZSQLExtendFolder):
             proj2=[]              proj2=[]
             for x in proj:              for x in proj:
                 if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):                  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)):                      # furchtbarer hack um sicher zustellen dass christoph hoffmann nicht mit Dieter Hoffmann verwechselt wird.
                
                       if not((splitted[1]=="Christoph") and (splitted[0]=="Hoffmann") and (  (("%s"%x.WEB_title).find('Einstein')>0) or (("%s"%x.WEB_title).find('Quantum')>0))):
                          logging.info("XXXXXXXXXXXXXXXXXXXXXXXX")
                        proj2.append(x)                         proj2.append(x)
   
         else:          else:
Line 1286  class MPIWGRoot(ZSQLExtendFolder): Line 1406  class MPIWGRoot(ZSQLExtendFolder):
   
         proj2.sort(sortP)          proj2.sort(sortP)
   
         if len(proj2)>0:          projectListe=[]
             ret.append((y,proj2))          
           for proj in proj2:   
               obj=proj.getObject()
               if onlyArchived==1: #nur aktuell projecte
                   if not obj.isArchivedProject():
                       projectListe.append(proj)
               elif onlyArchived==2: #nur archivierte
                   if obj.isArchivedProject():
                       projectListe.append(proj)
               else: #alle
                   projectListe.append(proj)
                       
                       
                   
           if len(projectListe)>0:
               ret.append((name,projectListe))
   
         return ret          return ret
             
Line 1333  class MPIWGRoot(ZSQLExtendFolder): Line 1468  class MPIWGRoot(ZSQLExtendFolder):
 ##                     objs.append((obj,lastName+", "+firstName))  ##                     objs.append((obj,lastName+", "+firstName))
   
                   
         return objs  ##        return objs
   
   
     def personCheck(self,names):      def personCheck(self,names):
Line 1366  class MPIWGRoot(ZSQLExtendFolder): Line 1501  class MPIWGRoot(ZSQLExtendFolder):
         return (fieldname in checkFields)          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()
       
       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":
              
   
               dh=getattr(self,'deletedHistoricalNames',{})
           
           if type(dh) is ListType:
           dh={}
               if not dh.has_key(name):
                   dh[name]=occurrances.split("\n")
               else:
                   dh[name]+=occurrances.split("\n")
               
               self.deletedHistoricalNames=dh
               
               del self.nameIndexEdited[name]
               
           
           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
      
         
           if RESPONSE is not None:
               RESPONSE.redirect('editNameIndexHTML')
           
       
       
       def restoreIndex(self):
           """restore"""
           self.nameIndexEdited=self.nameIndex
           return "done"
       
   
               
 def manage_addMPIWGRootForm(self):  def manage_addMPIWGRootForm(self):
     """form for adding the root"""      """form for adding the root"""
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)
Line 1433  class MPIWGProject(CatalogAware,Folder): Line 1688  class MPIWGProject(CatalogAware,Folder):
     meta_type='MPIWGProject'      meta_type='MPIWGProject'
     default_catalog='ProjectCatalog'      default_catalog='ProjectCatalog'
   
       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):
Line 1475  class MPIWGProject(CatalogAware,Folder): Line 1734  class MPIWGProject(CatalogAware,Folder):
         for split in  splitted[1:]:          for split in  splitted[1:]:
                 tmp=split.split("</p>")                  tmp=split.split("</p>")
                 #return repr(splitted[1])                  #return repr(splitted[1])
           
                 try:                  try:
                         imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))                          imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
                 except:                  except:
               
               try:
                         imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))                          imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
               except:
               imageURLs.append("")
                                   
                 split2="</p>".join(tmp[1:])                  split2="</p>".join(tmp[1:])
   
Line 1495  class MPIWGProject(CatalogAware,Folder): Line 1759  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 1520  class MPIWGProject(CatalogAware,Folder): Line 1779  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)
Line 1628  class MPIWGProject(CatalogAware,Folder): Line 1887  class MPIWGProject(CatalogAware,Folder):
   
     def getImages(self):      def getImages(self):
         """get all Images"""          """get all Images"""
   
         def sort_images(x,y):          def sort_images(x,y):
             return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
   
       if (getattr(self,'imageURL','')!='') or  (getattr(self,'imagecap','')!='')  :
           try:
           self.addImage(None,getattr(self,'imagecap',''),RESPONSE=None,filename=getattr(self,'imageURL',''))
           except:
           pass
           self.imageURL=''
           self.imagecap=''
   
         images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])          images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
                   
         images.sort(sort_images)          images.sort(sort_images)
Line 1651  class MPIWGProject(CatalogAware,Folder): Line 1920  class MPIWGProject(CatalogAware,Folder):
             RESPONSE.redirect('manageImages')              RESPONSE.redirect('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 1661  class MPIWGProject(CatalogAware,Folder): Line 1930  class MPIWGProject(CatalogAware,Folder):
         else:          else:
              return False               return False
                     
            
     def addImage(self,fileHd,caption,RESPONSE=None,filename=None):      def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
         """add an MPIWG_Project_image"""          """add an MPIWG_Project_image"""
   
Line 1677  class MPIWGProject(CatalogAware,Folder): Line 1947  class MPIWGProject(CatalogAware,Folder):
         obj.caption=caption[0:]          obj.caption=caption[0:]
         obj.enabled=True;          obj.enabled=True;
         obj.place=self.getLastImageNumber()+1          obj.place=self.getLastImageNumber()+1
           obj.id=filename
                   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manageImages')              RESPONSE.redirect('manageImages')
Line 1798  class MPIWGProject(CatalogAware,Folder): Line 2069  class MPIWGProject(CatalogAware,Folder):
   
   
     def generateTemplate(self,RESPONSE=None):      def generateTemplate(self,RESPONSE=None):
         """Erzeuge Template für defined fields not_used"""          """Erzeuge Template fuer defined fields not_used"""
   
         id="index_html"          id="index_html"
         title=id          title=id
Line 1844  class MPIWGProject(CatalogAware,Folder): Line 2115  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=getattr(self,'completedAt',0)
          
          #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 getCompletedAt(self):
           """gibt das transformierte Datum zurŸck"""
           date=getattr(self,'completedAt','')
           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))
           return """%s.%s.%s"""%(day,month,year);
           
           
       def transformDate(self,date):
           """transformiert ein Datum von DD.MM.YYYY, MM.YYYY,YYYY nach  YYYYMMDD, alle nicht angebebenn Werte
           werden auf 0 gesetzt, es wird null zurŸckgegeben falls das Datum ungueltig ist""" 
           
           if (date=="" ) :
               return "";
           
           if (date==None):
               return None;
           
           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 1889  class MPIWGProject(CatalogAware,Folder): Line 2243  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
           ranges=[] #Array mit tupeln x,y wobei x die Position des Anfang und y des Endes der i-ten Umgebung angiebt
           
           def isInRanges(nr,length):
               """test ob eine gegeben Position nr schon irgendwo in einer Umgebung ist, gibt den Index des ersten Wertes aus ranges zurueck, 
               -1, wenn kein Treffer
               
               @param nr: Position die geprueft werden soll
               @param length: Laenge des Wortes das geprueft werden soll
               """
               for x in ranges:
                   if (x[0]<=nr) and (nr < (x[1]-length)):
                       return ranges.index(x)
               return -1
                   
           # deal with phrases, in Phrasen werden die Leerzeichen durch "_" ersetzt.
           def rep_empty(str):
               x= re.sub(" ","_",str.group(0))
               return re.sub("\"","",x)
               
           wordStr=re.sub("\".*?\"", rep_empty,wordStr)#ersetze leerzeichen in " " durch "_" und loesche "
           
           #deal with wildcards, for our purposes it is enough to delete the wildcard 
           wordStr=wordStr.replace("*","")
           
           words=wordStr.split(" ")
           #if not words is ListType:
           #   words=[words]
               
           txt=self.harvest_page()
           if not txt:
               return ret
           txt=re.sub("<.*?>", "", txt) # loesche alle Tags
           for word in words:
               word=re.sub("_"," ",word) # ersetze zurueck "_" durch " "
               pos=0
               
               n=txt.lower().count(word.lower()) # wie oft tritt das Wort auf
   
               for i in range(n):
                   pos=txt.lower().find(word.lower(),pos)
   
                   if pos > 0:
                       x=max(0,pos-length)
                       y=min(len(txt),pos+length)
                     
                       
                       #is word already in one of the results
                       nr=isInRanges(pos,len(word))
                       if nr >=0:# word ist in einer schon gefunden Umgebung, dann vergroessere diese
                           x=min(ranges[nr][0],x)
                           y=max(ranges[nr][1],y)
                 
                       str=txt[x:y]
                   
                       if nr >=0: # word ist in einer schon gefunden Umgebung
                           ranges[nr]=(x,y) # neue Position der Umgebung
   
                           ret[nr]=str # neue Umgebung
                       else: # andernfalls neue Umgebung hinzufuegen
                           ranges.append((x,y))
   
                           ret.append(str)
                       
                       pos=pos+len(word)
                   else:
                       break;
                   
           # now highlight everything        
           if tagging:
               for x in range(len(ret)):
                   for word in words:
                       repl=re.compile(word,re.IGNORECASE)
                       ret[x]=repl.sub(""" <span class="found">%s</span>"""%word.upper(),ret[x])
   
           return ret
                                   
       def harvest_page(self,context=None):
           """seite fuer harvesting fuer die Projektsuche"""
           if not context:
               context=self
               
           if self.isActiveProject() and self.isActual():
                ext=getattr(self,"harvest_main",None)
                if ext:
                    return getattr(self,ext.getId())()
   
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)    
   
   
                return pt()
            
     def index_html(self,request=True,context=None):      def index_html(self,request=True,context=None):
         """show homepage"""          """show homepage"""
         if not context:          if not context:
Line 1967  class MPIWGProject(CatalogAware,Folder): Line 2423  class MPIWGProject(CatalogAware,Folder):
                 try:                  try:
                         self.imageURL=tmp[0].split("\"")[1].encode('utf-8')                          self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
                 except:                  except:
               try:
                         self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')                          self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
               except:
               self.imageURL=""
                                   
                 split2="</p>".join(tmp[1:])                  split2="</p>".join(tmp[1:])
   
Line 1990  class MPIWGProject(CatalogAware,Folder): Line 2449  class MPIWGProject(CatalogAware,Folder):
         else:          else:
             text5=text2              text5=text2
   
         #teste ob WEB_project_description und keine führenden p tags          #teste ob WEB_project_description und keine fuehrenden p tags
         if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):          if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
             text5= "<p>"+text5+"</p>"              text5= "<p>"+text5+"</p>"
   
   
         #filter image          #filter image
                   
           text5=text5.lstrip().rstrip() #loescher leerzeichen und einzelndes br
       if (text5=="<br>") or (text5=="<br/>"):
           text5=""
   
       logging.debug("getcontent: field=%s filter=%s -> %s"%(field,filter,repr(text5)))
           #return unicodify(text5)
           return utf8ify(text5) # return as utf-8 byte string
   
         return text5.encode('utf-8')  
   
     def showImagesOfPage(self,imageUrl=None):      def showImagesOfPage(self,imageUrl=None):
         """show Images of project"""          """show Images of project"""
Line 2117  class MPIWGProject(CatalogAware,Folder): Line 2582  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')
           
           if self.REQUEST.has_key('historicalNames'):
               self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))
           
         if self.REQUEST.has_key('active'):          if self.REQUEST.has_key('active'):
             self.setActiveFlag(True)              self.setActiveFlag(True)
         else:          else:
Removed from v.1.47.2.54  
changed lines
  Added in v.1.47.2.81

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