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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.14 and 1.47.2.57

version 1.14, 2004/07/08 11:42:31 version 1.47.2.57, 2006/08/15 13:27:43
Line 1 Line 1
 """This contains the class MPIWG Projects  """This contains the class MPIWG Projects
 for organizing and maintaining the different projectspages  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: 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.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder  from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
   from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from OFS.Image import Image
   from Globals import package_home
 import urllib  import urllib
 import MPIWGStaff  import MPIWGStaff
 import string  import string
 import re  import re
   import os
 from types import *  from types import *
   import zLOG
 import xmlhelper # Methoden zur Verwaltung der projekt xmls  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 AccessControl import ClassSecurityInfo
 from bibliography import *  from bibliography import *
   import time
   import xml.dom.minidom
   import sys
   from Ft.Xml.XPath import Evaluate
   from Ft.Xml.XPath.Context import Context
   from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
   from Ft.Xml import EMPTY_NAMESPACE
   
 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']
   
   
   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):  def sortF(x,y):
     try:      try:
         return cmp(x[1],y[1])          return cmp(x[1],y[1])
     except:      except:
           try:
               return cmp(str(x[1]),str(y[1]))
           except:           
               
         return 0          return 0
           
 def sortI(x,y):  def sortI(x,y):
Line 53  def sortI(x,y): Line 103  def sortI(x,y):
     except:      except:
         return cmp(x[1],y[1])          return cmp(x[1],y[1])
   
   class MPIWGLink(SimpleItem):
       """create a symbolic link to another page"""
   
       meta_type="MPIWGLink"
       
       def isActiveItem(self):
           """teste ob ausgewaehlt"""
           #url1 beim link anstelle von url1, da link jeweils index_html als url hat.
           if self.absolute_url()==self.REQUEST['URL1']:
               return "aktiv"
           else:
               return ""
   
       def __init__(self,id,link,title='',weight=''):
           """init mpiwglink"""
           self.id=id
           self.link=link
           self.title=title
           self.weight=weight
   
       def getObj(self):
           """bekomme original"""
          ##  objpath=self.link.replace("/",".")
   ##         if objpath[0]!=".":
   ##             objpath="."+objpath
   
   ##         print objpath
   ##         return eval("self"+objpath)
   
   
           splitted=self.link.lstrip().split("/")
           obj=self
           for x in splitted:
               if not x=="":
                 obj=getattr(obj,x)
               
           return obj
   
       def getWeight(self):
           if self.linkWeight and linkWeight!="":
               return self.linkWeight
           else:
               return self.getObj().weight
   
       manage_options=SimpleItem.manage_options+(
           {'label':'main config','action':'changeLinkForm'},
           )
   
   
       def changeLinkForm(self):
           """change MPIWG link"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGLinkChange.zpt')).__of__(self)
           return pt()
   
       def changeLink(self,link,title,weight,RESPONSE=None):
           """change links"""
           self.link=link
           self.title=title
           self.weight=weight
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage')
   
       def index_html(self):
           """index"""
           
           return self.getObj().pt_render(extra_context={'here':self})
                                          
   
   def manage_addMPIWGLinkForm(self):
       """Form for adding link"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGLink.zpt')).__of__(self)
       return pt()
   
   def manage_addMPIWGLink(self,id,link,title,weight,RESPONSE=None):
       """add link"""
       newObj=MPIWGLink(id,link,title,weight)
   
       self._setObject(id,newObj)
       
       if RESPONSE is not None:
           RESPONSE.redirect('manage_main')
   
   
   class MPIWGTemplate(ZopePageTemplate):
       """Create a layout Template for different purposes"""
   
       meta_type="MPIWGTemplate"
   
       manage_options=ZopePageTemplate.manage_options+(
           {'label':'Change Weight','action':'changeWeightForm'},
           )
   
       def changeWeightForm(self):
           """change weight form"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGTemplateChangeWeight.zpt')).__of__(self)
           return pt()
   
       def changeWeight(self,weight,RESPONSE=None):
           """change weight"""
           self.weight=weight
           if RESPONSE is not None:
               RESPONSE.redirect('manage')
   
           
       def __init__(self, id, text=None, content_type=None,MPIWGType=None):
           self.id = str(id)
   
   
   
           self.ZBindings_edit(self._default_bindings)
           if text is None:
               self._default_content_fn = os.path.join(package_home(globals()),
                                                  'zpt/MPIWG_%s_template_standard.zpt'%MPIWGType)
               text = open(self._default_content_fn).read()
           self.pt_edit(text, content_type)
   
       
           """change form"""
   
       def isActiveItem(self):
           """teste ob ausgewaehlt"""
           if self.absolute_url()==self.REQUEST['URL']:
               return "aktiv"
           else:
               return ""
           
   def manage_addMPIWGTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGTemplate.zpt')).__of__(self)
       return pt()
   
   from urllib import quote
   
   
   def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):
       "Add a Page Template with optional file content."
       if type(MPIWGType)==StringType:
           MPIWGTypes=[MPIWGType]
       else:
           MPIWGTypes=MPIWGType
           
       for singleType in MPIWGTypes:
   
   
           if REQUEST is None:
               self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))
               ob = getattr(self, id)
               
               if title:
                   ob.pt_setTitle(title)
               return ob
           else:
               file = REQUEST.form.get('file')
               headers = getattr(file, 'headers', None)
               if headers is None or not file.filename:
                   zpt = MPIWGTemplate(id,MPIWGType=singleType)
               else:
                   zpt = MPIWGTemplate(id, file, headers.get('content_type'))
   
               self._setObject(id, zpt)
               ob = getattr(self, id)
               if title:
                   ob.pt_setTitle(title)
   
               try:
                   u = self.DestinationURL()
               except AttributeError:
                   u = REQUEST['URL1']
   
       ob = getattr(self, id)
       ob.weight=weight
       
       REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
           
 class MPIWGRoot(ZSQLExtendFolder):  class MPIWGRoot(ZSQLExtendFolder):
     """Stammordner für den Web-Server"""      """Stammordner für den Web-Server"""
Line 60  class MPIWGRoot(ZSQLExtendFolder): Line 286  class MPIWGRoot(ZSQLExtendFolder):
     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',
              'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',               'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',
              'xdata_08':'Other involved scholars' ,'xdata_09':'Part of','xdata_10':'Covered by',               'xdata_08':'Other involved scholars' ,'xdata_09':'Disciplines','xdata_10':'Themes',
              'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',               'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',
              'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',               'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',
              'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}               'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}
           
     folders=['MPIWGProject','Folder']      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):
           """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 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
               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 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):      def replaceNotEmpty(self,format,field):
         """replace not empty"""          """replace not empty"""
         if field and (not field==''):          if field and (not field.lstrip()==''):
             return format%field              return format%field
         else:          else:
             return ""              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):      def formatBibliography(self,here,found):
         """format"""          """format"""
         return formatBibliography(here,found)          return formatBibliography(here,found)
           
     def getValue(self,field):      def getValue(self,fieldStr):
         """Inhalt des Feldes"""          """Inhalt des Feldes"""
   
         if type(field)==StringType:          if type(fieldStr)==StringType:
               field=fieldStr
           else:
               field=fieldStr[0]
             try:              try:
                 if field[len(field)-1]==";":                  if field[len(field)-1]==";":
                     field=field[0:len(text)-1]                  field=field[0:len(field)-1]
             except:              except:
                     """nothing"""  
                           
               """nothing"""
           field=re.sub(r';([^\s])','; \g<1>',field)
             return field.encode('utf-8')              return field.encode('utf-8')
                   
         else:  
             return field[0].encode('utf-8')  
   
           
     def sortedNames(self,list):      def sortedNames(self,list):
Line 140  class MPIWGRoot(ZSQLExtendFolder): Line 561  class MPIWGRoot(ZSQLExtendFolder):
         self.id=id          self.id=id
         self.title=title          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):      def urlQuote(self,str):
         """quote"""          """quote"""
         return urllib.quote(str)          return urllib.quote(str)
Line 188  class MPIWGRoot(ZSQLExtendFolder): Line 625  class MPIWGRoot(ZSQLExtendFolder):
                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])                              list[urllib.quote(personNormal)]=(personNormal,[project[1]])
   
             except:              except:
                 print "ERROR",project                  zLOG.LOG("MPIWG Web (harvestHistoricalPerson)",zLOG.ERROR,"cannot analyize: %s"%repr(project))
   
                                   
         return list          return list
   
Line 219  class MPIWGRoot(ZSQLExtendFolder): Line 657  class MPIWGRoot(ZSQLExtendFolder):
   
     def showHistoricalPersons(self):      def showHistoricalPersons(self):
         """show persons"""          """show persons"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/showHistoricalPersons').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','showHistoricalPersons')).__of__(self)
         return pt()          return pt()
   
                   
     def editHistoricalPersonsForm(self):      def editHistoricalPersonsForm(self):
         """edit historical persons for consistency"""          """edit historical persons for consistency"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/editHistoricalPersonsForm').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','editHistoricalPersonsForm')).__of__(self)
         return pt()          return pt()
   
     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry):      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 enthält ein Element der Liste fieldContents"""
           def sort(x,y):
                   return cmp(x.WEB_title[0],y.WEB_title[0])
   
         if type(fieldContentsEntry) is StringType:          if type(fieldContentsEntry) is StringType:
             fieldContents=[fieldContentsEntry]              fieldContentsTmp=[fieldContentsEntry]
         else:          else:
             fieldContents=fieldContentsEntry              fieldContentsTmp=fieldContentsEntry
                           
         projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' OR')})          fieldContents=[]
           for x in fieldContentsTmp:
               fieldContents.append(" AND ".join(x.split()))
           projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' AND')})
         #print projects          #print projects
         return 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):      def changeMPIWGRootForm(self):
         """edit"""          """edit"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/changeMPIWGRootForm').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGRootForm')).__of__(self)
         return pt()          return pt()
   
     def changeMPIWGRoot(self,title,disciplineList,themesList,RESPONSE=None):      def changeMPIWGRoot(self,title,disciplineList,themesList,connection_id,RESPONSE=None):
         """change"""          """change"""
         self.title=title          self.title=title
           self.connection_id=connection_id
         self.disciplineList=disciplineList          self.disciplineList=disciplineList
         self.themesList=themesList          self.themesList=themesList
   
Line 255  class MPIWGRoot(ZSQLExtendFolder): Line 710  class MPIWGRoot(ZSQLExtendFolder):
   
     def getDisciplineList(self):      def getDisciplineList(self):
         """get disciplines as list"""          """get disciplines as list"""
         return self.disciplineList.split("\n")          list= self.disciplineList.split("\n")
           return [x.rstrip().lstrip() for x in list]
           
     def getThemeList(self):      def getThemeList(self):
         """get themes as list"""          """get themes as list"""
         return self.themesList.split("\n")          list= self.themesList.split("\n")
           return [x.rstrip().lstrip() for x in list]
           
     def test(self):      def test(self):
         """test"""          """test"""
         return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url          return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url
   
     def getContexts(self,childs=None,parents=None,depth=None):      def getContexts(self,childs=None,parents=None,depth=None,date=None,onlyActive=True):
         """childs alle childs, alle parents"""          """childs alle childs, alle parents"""
         ret=[]          ret=[]
           
         if parents:          if parents:
             splitted=parents.split(".")              splitted=parents.split(".")
             parentId=string.join(splitted[0:len(splitted)-1],".")              parentId=string.join(splitted[0:len(splitted)-1],".")
                   
             for project in self.getProjectFields('xdata_05',sort='int'):              for project in self.getProjectFields('xdata_05',sort='int',date=date):
                 if project[1]==parentId:                  if project[1]==parentId:
                     ret.append(project)                      ret.append(project)
   
         if childs:          if childs:
             for project in self.getProjectFields('xdata_05',sort='int'):              for project in self.getProjectFields('xdata_05',sort='int',date=date):
                 searchStr=childs+"(\..*)"                  searchStr=childs+"(\..*)"
                  
                   if (onlyActive and project[0].isActiveProject()) or (not onlyActive):
                 if re.match(searchStr,project[1]):                  if re.match(searchStr,project[1]):
                                           
                     if depth:                      if depth:
Line 290  class MPIWGRoot(ZSQLExtendFolder): Line 750  class MPIWGRoot(ZSQLExtendFolder):
                         ret.append(project)                          ret.append(project)
         return ret          return ret
           
     def getProjectFields(self,fieldName,folder=None,sort=None):      def getProjectFields(self,fieldName,date=None,folder=None,sort=None):
         """getListofFieldNames"""          """getListofFieldNames"""
         ret=[]          ret=[]
         #print "FN",fieldName      
         if not folder:          objects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'],search_sub=0)
             folder=self  
         for object in folder.__dict__:                  
           for object in objects:
             obj=getattr(folder,object)              obj=object[1]
             if hasattr(obj,'meta_type'):              obj=obj.getActualVersion(date)
                 #print obj.meta_type              if obj and (not getattr(obj,'invisible',None)):
                 if obj.meta_type=='MPIWGProject':  
                     if fieldName=="WEB_title_or_short":                      if fieldName=="WEB_title_or_short":
                         #print "HI!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"  
                         #print len(obj.getContent('xdata_07'))  
                         if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer                          if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer
                             fieldNameTmp="WEB_title"                              fieldNameTmp="WEB_title"
                         else:                          else:
Line 314  class MPIWGRoot(ZSQLExtendFolder): Line 772  class MPIWGRoot(ZSQLExtendFolder):
                                           
                     ret.append((obj,obj.getContent(fieldNameTmp)))                      ret.append((obj,obj.getContent(fieldNameTmp)))
   
                 if obj.meta_type in self.folders:  
                       
                     ret += self.getProjectFields(fieldName,obj)  
   
         if sort=="int":          if sort=="int":
             ret.sort(sortI)              ret.sort(sortI)
           elif sort=="stopWords":
               print "sortStop"
               ret.sort(sortStopWords(self))
               
         else:          else:
             ret.sort(sortF)              ret.sort(sortF)
                   
Line 328  class MPIWGRoot(ZSQLExtendFolder): Line 787  class MPIWGRoot(ZSQLExtendFolder):
     def showNewProjects(self):      def showNewProjects(self):
         projects=[]          projects=[]
         for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets          for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets
             if objs[0].xdata_05[0] == "":              if objs[0].xdata_05 and (objs[0].xdata_05[0] == ""):
                                   
                 projects.append(objs)                  projects.append(objs)
                                   
Line 336  class MPIWGRoot(ZSQLExtendFolder): Line 795  class MPIWGRoot(ZSQLExtendFolder):
           
                   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Import Persons','action':'importNamesForm'},          {'label':'Update personal homepages','action':'updateHomepages'},
           {'label':'Reindex catalogs','action':'reindexCatalogs'},
         {'label':'Main config','action':'changeMPIWGRootForm'},          {'label':'Main config','action':'changeMPIWGRootForm'},
         {'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):      def importNamesForm(self):
         """Form"""          """Form"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGNamesForm.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):      def importNames(self,fileupload,folderName,RESPONSE=None):
Line 356  class MPIWGRoot(ZSQLExtendFolder): Line 816  class MPIWGRoot(ZSQLExtendFolder):
                           
                           
             splitted=line.split(",")              splitted=line.split(",")
             print splitted             # print splitted
                   
             if not (splitted[0]==""):              if not (splitted[0]==""):
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])                  newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])
                                   
                 try:                  try:
                     project._setObject(splitted[0],newObj)                      project._setObject(splitted[0],newObj)
                     print "done:",splitted[0]                      #print "done:",splitted[0]
                 except:                  except:
                     print "not done:",splitted[0]                      zLOG.LOG("MPIWG Web (importNames)",zLOG.INFO,"cannot import: %s"%splitted[0])
   
                                           
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def getAllMembers(self):      def updatePublicationDB(self,personId=None):
         """give list of all members"""          """updates the publication db, i.e. copy year into the main table"""
         ret=[]          
           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):
           """ update"""
           
           RESPONSE.setHeader('Content-type', 'text/html')
           RESPONSE.write("<html><body>\n")
           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'}):
   
         #for x in self.members.objectValues('MPIWGStaff'):              username=getTextFromNode(row.xpath('./dn:username',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
             #print x.title              id=getTextFromNode(row.xpath('./dn:ID',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
         #    ret.append(x.title.decode('utf-8'))              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:
                   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)
                   
                   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>")
   
         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):          return True
                                ret.append(x[1].title.decode('utf-8'))       
       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])
               
           
       
           
              
           if RESPONSE:
               RESPONSE.redirect('manage_main')
   
           
           
       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()          #ret.sort()
   #            self._v_membersList=ret[0:]
         #print ret          #print ret
   #  
   #        return self._v_membersList
       
         return ret      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):      def printAllMembers(self):
         """prin"""          """print"""
         members=self.getAllMembers()          members=self.getAllMembers()
         ret=""          ret=""
         for x in members:          for x in members:
Line 403  class MPIWGRoot(ZSQLExtendFolder): Line 1076  class MPIWGRoot(ZSQLExtendFolder):
             return entry              return entry
   
   
     def getTree(self):      def getTree(self,date=None,onlyActive=None):
         """generate Tree from project list"""          """generate Tree from project list"""
   
         returnList=[]          returnList=[]
         for project in self.getProjectFields('xdata_05',sort="int"): # 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
                 if not idNr=="":                  if not idNr=="":
                     splittedId=idNr.split(".")                      splittedId=idNr.split(".")
Line 416  class MPIWGRoot(ZSQLExtendFolder): Line 1091  class MPIWGRoot(ZSQLExtendFolder):
                     title=[project[0].getContent('WEB_title')]                      title=[project[0].getContent('WEB_title')]
                     #print title                      #print title
                                           
                     returnList.append((depth,nr,title,project[0]))                      if idNr[0]=="x": # kompatibilitŠt mit alter Konvention, x vor der Nummer macht project inactive
                           project[0].setActiveFlag(False)
                   
                       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          return returnList
   
       def formatElementsAsList(self,elements):
           """formatiere tree als liste"""
           
           actualDepth=0
           ret=""
           for element in elements:
               if (element[0]>actualDepth):
                   #fuege soviele ul ein wie unterschied in tiefe
                   if element[0]==1:
                       ret+="""<div class="dept">\n<ul class="liste">\n"""
                   else:
                       for i in range(element[0]-actualDepth):
                           if i>0:
                               ret+="<li>"
                           ret+="""<ul class="liste">\n"""
   
                   actualDepth=element[0]
                   
               elif (element[0]<actualDepth):
                   #fuege soviele /ul ein wie unterschied in tiefe
                   for i in range(-element[0]+actualDepth):
   
                       ret+="<br><br></li></ul>\n"
   
                       #ret+="<br><br>\n</li>\n</ul>\n</li>\n"
   
   
                   if element[0]==1:
                       department=int(element[3].getContent('xdata_05'))-1
                       
                       ret+="""</ul></div>\n"""
                       if department==4: #hack
                           department=3
   
                       ret+="""<div class="bildspalte"><img src="../grafik/dept%i.jpg" width="160" height="120" vspace="40"></div>
                       <div class="dept">\n<ul class="liste">\n
                       """%department
               
                   actualDepth=element[0]
               else:
                   ret+="""\n</li>\n"""
               ret+="""<li>\n"""
               
               if actualDepth==1:
                   departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'Ind. Research Group','5':'Ind. Research Group','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 """<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):
         """Change Postion Entry"""          """Change Postion Entry"""
         numbers=[]          numbers=[]
Line 460  class MPIWGRoot(ZSQLExtendFolder): Line 1214  class MPIWGRoot(ZSQLExtendFolder):
   
                   
         for idNr in form.keys():          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].xdata_05=form[idNr]
                       fields[int(idNr)][3].copyObjectToArchive()
   
                   if form.has_key(idNr+'_active'): # active flag is set
                   
                       fields[int(splitted[0])][3].setActiveFlag(True)
                   else:
                     
                       fields[int(splitted[0])][3].setActiveFlag(False)
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('showTree')              RESPONSE.redirect('showTree')
Line 478  class MPIWGRoot(ZSQLExtendFolder): Line 1243  class MPIWGRoot(ZSQLExtendFolder):
                   
                           
                   
       def getRelativeUrlFromPerson(self,list):
           """get urls to person list"""
           ret=[]
           persons=list.split(";")
           for person in persons:
               
               if len(person)>1: #nicht nur Trennzeichen
                   splitted=person.split(",")
                   if len(splitted)==1:
                       splitted=person.split(" ")
                   splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
                   if splittedNew[0]=='':
                       del splittedNew[0]
                   search=string.join(splittedNew,' AND ')
                   
                   if not search=='':
   
                       try:
                           proj=self.MembersCatalog({'title':search})
                       except:
                           proj=None
   
                   if proj:
                       #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
                       ret.append("<a href=%s >%s</a>"%('members/'+proj[0].id+'/index.html',person))
                   else:
                       #ret.append("%s"%person.encode('utf-8'))
                       ret.append("%s"%person)
           return string.join(ret,";")
                   
                           
     def getUrlFromPerson(self,list):      def getUrlFromPerson(self,list):
Line 489  class MPIWGRoot(ZSQLExtendFolder): Line 1283  class MPIWGRoot(ZSQLExtendFolder):
             if len(person)>1: #nicht nur Trennzeichen              if len(person)>1: #nicht nur Trennzeichen
                 splitted=person.split(",")                  splitted=person.split(",")
                 if len(splitted)==1:                  if len(splitted)==1:
                     splitted=person.split(" ")                      splitted=person.lstrip().rstrip().split(" ")
                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]                  splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
                 if splittedNew[0]=='':                  if splittedNew[0]=='':
                     del splittedNew[0]                      del splittedNew[0]
Line 502  class MPIWGRoot(ZSQLExtendFolder): Line 1296  class MPIWGRoot(ZSQLExtendFolder):
                     except:                      except:
                         proj=None                          proj=None
   
                 if proj:                  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')))                      #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))                      ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url+"/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)
         return string.join(ret,";")          return string.join(ret,";")
                                                     
     def getProjectsOfMembers(self):      def getProjectsOfMembers(self,date=None):
         """give tuple member /projects"""          """give tuple member /projects"""
         ret=[]          ret=[]
         members=self.getAllMembers()          members=self.getAllMembers()
          
         #return str(members)          #return str(members)
         for x in members:          for x in members:
             ret+=self.getProjectsOfMember(name=x)           
               ret+=self.getProjectsOfMember(name=x,date=date)
   
         return ret          return ret
   
     def getProjectsOfMember(self,name=None,email=None):      def getProjectsOfMember(self,name=None,email=None,date=None):
         """get project of a member"""          """get project of a member"""
         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.xdata_05,y.xdata_05)              return cmp(x.WEB_title,y.WEB_title)
                   
     
         ret=[]          ret=[]
         splitNeu=[]          splitNeu=[]
         if email:          if email:
             members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email])              
               members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email],search_sub=1)
             name =  members[0][1].title.decode('utf-8')              name =  members[0][1].title.decode('utf-8')
   
         y=name          y=name
         splitted=y.split(",")            splitted=y.split(",")  
         for s in splitted:          #XXXX
             splitNeu.append("\""+s+"\"")          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})
   
         if proj:          if proj:
             proj2=[x for x in proj]              proj2=[]
             proj2.sort(sortP)              for x in proj:
             ret.append((y,proj2))                  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})          proj=self.ProjectCatalog({'xdata_08':search})
         if proj:          if proj:
             proj2=[x for x in 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)              proj2.sort(sortP)
             ret.append((y,proj2))  
   
           if len(proj2)>0:
               ret.append((y,proj2))
                   
         return ret          return ret
             
Line 560  class MPIWGRoot(ZSQLExtendFolder): Line 1375  class MPIWGRoot(ZSQLExtendFolder):
                   
         splitted=name.split(",")          splitted=name.split(",")
         if len(splitted)==1:          if len(splitted)==1:
             splitted=name.split(" ")              splitted=name.lstrip().rstrip().split(" ")
         splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]          splittedNew=[split.lstrip() for split in splitted]
           
         if splittedNew[0]=='':          if splittedNew[0]=='':
             del splittedNew[0]              del splittedNew[0]
         search=string.join(splittedNew,' AND ')          search=string.join(splittedNew,' AND ')
           
         if not search=='':          if not search=='':
             proj=self.MembersCatalog({'title':search})              proj=self.MembersCatalog({'title':search})
   
Line 628  class MPIWGRoot(ZSQLExtendFolder): Line 1445  class MPIWGRoot(ZSQLExtendFolder):
         return (fieldname in checkFields)          return (fieldname in checkFields)
   
   
       
       
           
 def manage_addMPIWGRootForm(self):  def manage_addMPIWGRootForm(self):
     """form for adding the root"""      """form for adding the root"""
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGRootForm.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_addMPIWGRoot(self,id,title,RESPONSE=None):  def manage_addMPIWGRoot(self,id,title,connection_id="",RESPONSE=None):
     """add a root folder"""      """add a root folder"""
     newObj=MPIWGRoot(id,title)      newObj=MPIWGRoot(id,title)
     self._setObject(id,newObj)      self._setObject(id,newObj)
       ob=getattr(self,id)
       setattr(ob,'connection_id',connection_id)
     if RESPONSE is not None:      if RESPONSE is not None:
         RESPONSE.redirect('manage_main')          RESPONSE.redirect('manage_main')
                   
   
 class MPIWGProject(Folder):  class MPIWGProject_publication(SimpleItem):
       """publications object fuer project"""
   
       meta_type="MPIWGProject_publication"
   
       def editPublication(self,text=None,RESPONSE=None):
           """edit a publication"""
   
           if (not text):
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
               return pt()
   
          
           self.text=text[0:]
   
           if RESPONSE:
               RESPONSE.redirect("../managePublications")
               
   class MPIWGProject_image(Image):
       """Images for Projects"""
   
       meta_type="MPIWGProject_image"
   
       def showImage(self,imageUrl=None):
           """show Images at an extra page"""
           self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
           return pt()
       
       def editImage(self,file=None,caption=None,RESPONSE=None):
           """edit the Image"""
           if (not file) and (not caption):
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
               return pt()
   
           if file and (not file.filename.lstrip().rstrip()==""):
               self.manage_upload(file)
   
           if caption:
               self.caption=caption[0:]
   
           if RESPONSE:
               RESPONSE.redirect("../manageImages")
   
   class MPIWGProject(CatalogAware,Folder):
     """Class for Projects"""      """Class for Projects"""
   
   
       security=ClassSecurityInfo()
     meta_type='MPIWGProject'      meta_type='MPIWGProject'
       default_catalog='ProjectCatalog'
   
    
       def sortedByPlace(self,metatype):
           """find metatype and sort by place"""
           def sort(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
           founds=self.ZopeFind(self,obj_metatypes=[metatype]);
           
           founds.sort(sort)
           
           return founds
       
   
       def copyPublicationsToList(self,RESPONSE=None):
           """copy publications in to list"""
   
           publicationTxt=self.getContent('WEB_related_pub')
   
           pubSplits=publicationTxt.split("<p>")
   
           for pubSplit in pubSplits:
               pubSplit=pubSplit.replace("</p>","")
               self.addPublication(pubSplit)
   
           if RESPONSE:
               RESPONSE.redirect('managePublications')
           
       
       def copyImageToMargin(self,RESPONSE=None):  
           """copy inline images to marginal images"""
           
           
           #getImages from WEB_project_description
           description=self.getContent('WEB_project_description')
           
           text2=description
           splitted=text2.split("""<p class="picture">""")
           
           imageURLs=[]
           imageCaptions=[]
           for split in  splitted[1:]:
                   tmp=split.split("</p>")
                   #return repr(splitted[1])
                   try:
                           imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
                   except:
                           imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
                   
                   split2="</p>".join(tmp[1:])
   
   
                   splitted=split2.split("""<p class="picturetitle">""")
                   if len(splitted)>1:
                       tmp=splitted[1].split("</p>")
                       imageCaptions.append(tmp[0].encode('utf-8'))
   
   
                   else:
                       #keine caption
   
                       imageCaptions.append("")
                   
             
   
           
           
           
           
           #eintragen:
           for imageURL in imageURLs:
               filename=imageURL.split("/")[-1]
               #lege neues images object an, mit leerem bild
   
               if self.ZopeFind(self,obj_ids=[filename]):
                   #existiert das bild schon, dann neuen filenamen
                   filename="project_image_"+filename
               
               self.addImage(None,imageCaptions[imageURLs.index(imageURL)],filename=filename)
               #hole die bilddaten aus der url
               url=self.absolute_url()+"/"+imageURL
               #url=self.absolute_url()+"/"+filename
           
               try:#relative url
                   data=urllib.urlopen(url).read()
               except:
                   try:#absolute
                       data=urllib.urlopen(self.imageURL).read()
                   except:
                       zLOG.LOG("MPIWG Project",zLOG.ERROR,"can't open: %s"%url)
               
               obj=getattr(self,filename)
               obj.update_data(data)
           
           if RESPONSE:
               RESPONSE.redirect('manageImages')
               
       def manageImages(self,imageName=None,op=None):
           """managage images"""
   
   
           if imageName and op:
               if op=='up':
                   images=self.getImages()
                   for image in images:
                       if image[0]==imageName:
                           nr=images.index(image)
                           if not nr==0:
                               images[nr-1][1].place+=1
                               images[nr][1].place-=1
                           pass
               elif op=='down':
                   images=self.getImages()
                   for image in images:
                       if image[0]==imageName:
                           nr=images.index(image)
                           if not (nr==len(images)-1):
                               images[nr+1][1].place-=1
                               images[nr][1].place+=1
                           pass
   
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.zpt')).__of__(self)
           return pt()
   
       def managePublications(self,pubName=None,op=None):
           """managage images"""
   
   
           if pubName and op:
               if op=='up':
                   publications=self.getPublications()
                   for publication in publications:
                       if publication[0]==pubName:
                           nr=publications.index(publication)
                           if not nr==0:
                               publications[nr-1][1].place+=1
                               publications[nr][1].place-=1
                           pass
               elif op=='down':
                   publications=self.getPublications()
                   for publication in publications:
                       if publication[0]==pubName:
                           nr=publications.index(publication)
                           if not (nr==len(publications)-1):
                               publications[nr+1][1].place-=1
                               publications[nr][1].place+=1
                           pass
   
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
           return pt()
   
       def getPublications(self):
           """get all Publications"""
           def sort_images(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
           publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
           
           publications.sort(sort_images)
           return publications
   
       def addPublication(self,text,RESPONSE=None):
           """add an MPIWG_Publication"""
   
           name="publication_"+str(self.getLastPublicationNumber()+1)
           
           newPublication=MPIWGProject_publication(name)
   
           self._setObject(name,newPublication)
           obj=getattr(self,name)
           obj.text=text[0:]
           obj.enabled=True;
           obj.place=self.getLastPublicationNumber()+1
           obj.id=name
           
           if RESPONSE is not None:
               RESPONSE.redirect('managePublications')
   
    
       def getLastPublicationNumber(self):
           publications=self.getPublications()
           
           if not publications:
               return 0
           else:
               return getattr(publications[-1][1],'place',0)
           
       def deletePublication(self,id,RESPONSE=None):
           """delete Publication id"""
           self.manage_delObjects([id])
           if RESPONSE:
               RESPONSE.redirect('managePublications')
   
       def getImages(self):
           """get all Images"""
           def sort_images(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
           images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
           
           images.sort(sort_images)
           return images
   
       def getLastImageNumber(self):
           images=self.getImages()
           
           if not images:
               return 0
           else:
               return getattr(images[-1][1],'place',0)
           
       def deleteImage(self,id,RESPONSE=None):
           """delete Image id"""
           self.manage_delObjects([id])
           if RESPONSE:
               RESPONSE.redirect('manageImages')
   
       
       def hasChildren(self,date=None,onlyActive=True):
           """check if project has children"""
           ct=self.getContexts(childs=self.getContent('xdata_05'),
                                    depth=1,date=date,onlyActive=onlyActive)
           
           if ct and len(ct)>0:
                return True
           else:
                return False
            
       def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
           """add an MPIWG_Project_image"""
   
           if not filename:
               filename=fileHd.filename
   
           if not fileHd:
               fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
               
           newImage=MPIWGProject_image(filename,filename,fileHd)
   
           self._setObject(filename,newImage)
           obj=getattr(self,filename)
           obj.caption=caption[0:]
           obj.enabled=True;
           obj.place=self.getLastImageNumber()+1
           
           if RESPONSE is not None:
               RESPONSE.redirect('manageImages')
   
       def PrincipiaSearchSource(self):
           """Return cataloguable key for ourselves."""
           return str(self)
   
       def versionHeader(self):
           """version Header, gibt header text entsprechend der aktuellen version aus"""
           
           actualTime=time.localtime()
           retTXT="""<h2>This is an outdated version, for the actual version please refer to <a href="%s">%s</a></h2>"""
           s=self.aq_parent.absolute_url()
           #print getattr(self,'archiveTime',actualTime)
           if getattr(self,'archiveTime',actualTime)< actualTime:
               return retTXT%(s,s)
           else:
               return ""
   
       def getActualVersion(self,date=None):
           """actuelle version"""
           def sortProjectsByTime(x,y):
               return cmp(x[1].archiveTime,y[1].archiveTime)
   
           if not date:
               if self.isActual():
                   return self
               else:
                   return None
   
           #suche ob aeltere versionen vorhanden sind
   
           finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
           if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
               ad=getattr(self,'creationTime','20050101000000')
               if int(date)>int(ad):
                   return self
               else:
                   return None
   
   
           else:
               finds.sort(sortProjectsByTime)
   
           for find in finds:
               #gehe durch die alten Projekte und finde das entprechende
               if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
                   return find[1]
   
           #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
           ad=getattr(self,'creationTime','20050101000000')
           
           if int(date)>int(ad):
           
               return self
           else:
               return None
             
           
       def isActual(self):
           """gibt 1 zurueck wenn aktuell, 0 sonst"""
           actualTime=time.localtime()
           
           
           #print getattr(self,'archiveTime',actualTime)
           if getattr(self,'archiveTime',actualTime)< actualTime:
               return 0
           else:
               return 1
           
       def copyObjectToArchive(self):
           """kopiere aktuelles objekt ins archiv"""
           cb=self.aq_parent.manage_copyObjects(self.getId())
           self.manage_pasteObjects(cb)
           actualTime=time.localtime()
           
           self.manage_renameObject(self.getId(),self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
           obj=getattr(self,self.getId()+"_"+time.strftime("%Y%m%d%H%M%S",actualTime))
           obj.setArchiveTime(time.strftime("%Y%m%d%H%M%S",actualTime))
           ids=[x[0] for x in self.ZopeFind(obj,obj_metatypes=['MPIWGProject'])]
           obj.manage_delObjects(ids)
           
       def setArchiveTime(self,time):
           """set Archive Time"""
           self.archiveTime=time[0:]
           
       def versionManageForm(self):
           """version Manage form:currently only set to invisible"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)
           return pt()
   
       def versionManage(self,invisible=None,RESPONSE=None):
           """version Manage form:currently only set to invisible"""
           self.invisible=invisible
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
     def crossLinker(self):      def crossLinker(self):
         """experimental crosslinker"""          """experimental crosslinker"""
Line 686  class MPIWGProject(Folder): Line 1893  class MPIWGProject(Folder):
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
                           
     def __init__(self, id, argv=None):      def __init__(self, id, argv=None):
         """initieriere classe"""          """initiere classe"""
                   
           self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]
         self.id=id          self.id=id
         self.title=id          self.title=id
           self.isActiveFlag=True #Flag is true is the project is still active, False if accomplished
           
         if argv:          if argv:
             for arg in definedFields:              for arg in definedFields:
         try:          try:
Line 706  class MPIWGProject(Folder): Line 1916  class MPIWGProject(Folder):
         {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},          {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
         {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},          {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
         {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},          {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
           {'label':'Versionmanager','action':'versionManageForm'},
         )          )
   
   
       def isActiveProject(self):
           """check if the project is still active, default is true, set to false is the project is accomplished"""
           return getattr(self,'isActiveFlag',True)
           
       def setActiveFlag(self,status=True):
           """set the active flag"""
           self.isActiveFlag=status
           
       def checkDate(self,date):
           """teste ob zum Zeitpunkt date eine andere version existierte"""
           
   
           def sortProjectsByTime(x,y):
               return cmp(x[1].archiveTime,y[1].archiveTime)
   
           #suche ob aeltere versionen vorhanden sind
   
           finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
           if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
               ad=getattr(self,'creationTime','20050101000000')
               if int(date)>int(ad):
                   return self.REQUEST['URL1']+"/"+self.getId()
               else:
                   return self.REQUEST['URL1']+"/no_project"
   
   
           else:
               finds.sort(sortProjectsByTime)
   
           for find in finds:
               #gehe durch die alten Projekte und finde das entprechende
               if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
                   return self.REQUEST['URL1']+"/"+find[1].getId()
   
           #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
           ad=getattr(self,'creationTime','20050101000000')
           
           if int(date)>int(ad):
           
               return self.REQUEST['URL1']+"/"+self.getId()
           else:
               return self.REQUEST['URL1']+"/no_project"
           
               
       def no_project(self):
           """warnung: project noch nicht existent"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)
           return pt()
        
       def getGetNeighbourhood(self,wordStr, length=100):
           """finde umgebung um die worte in wordStr, zurŸckgegeben 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 grš§e der Umgebung
           """
           
           ret=[] # nimmt das Array auf, dass spŠter zurŸckgegeben 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 zurŸck, 
               -1, wenn kein Treffer
               
               @param nr: Position die geprŸft werden soll
               @param length: LŠnge des Wortes das geprŸft 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()
          
           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 vergrš§ere 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 hinzufŸgen
                           ranges.append((x,y))
   
                           ret.append(str)
                       
                       pos=pos+len(word)
                   else:
                       break;
                   
           # now highlight everything        
           for x in range(len(ret)):
               for word in words:
                   repl=re.compile(word,re.IGNORECASE)
                   ret[x]=repl.sub(""" <span class="found">%s</span>"""%word.upper(),ret[x])
   
           return ret
                                   
       def harvest_page(self,context=None):
           """seite fuer harvesting fuer die Projektsuche"""
           if not context:
               context=self
               
           if self.isActiveProject() and self.isActual():
                ext=getattr(self,"harvest_main",None)
                if ext:
                    return getattr(self,ext.getId())()
   
                pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)    
   
   
                return pt()
            
       def index_html(self,request=True,context=None):
           """show homepage"""
           if not context:
               context=self
           if request:
               if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
                   self.REQUEST.SESSION['MPI_redirected']=1
                   self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date'])+"?date="+self.REQUEST['date'])
               else:
                   self.REQUEST.SESSION['MPI_redirected']=None
           
           #ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
           ext=getattr(self,"project_main",None)
           if ext:
               return getattr(self,ext.getId())()
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)    
   
           return pt()
   
       
     def getDataFields(self):      def getDataFields(self):
         """giveListofDatafields"""          """giveListofDatafields"""
         ret=[]          ret=[]
         for x in range(1,14):          for x in range(1,14):
               if not x in [6,10,9]: # not used fields
             ret.append('xdata_%02i'%x)              ret.append('xdata_%02i'%x)
         return ret          return ret
                           
Line 724  class MPIWGProject(Folder): Line 2106  class MPIWGProject(Folder):
         """get attrbiute"""          """get attrbiute"""
         return getattr(self,field)          return getattr(self,field)
   
     def getContent(self,field):      def getContent(self,field,filter=None):
         """Inhalt des Feldes"""          """Inhalt des Feldes"""
                   
         text=u''          text=u''
         #print "FIELD",field  
         for x in getattr(self,field):          for x in getattr(self,field):
             #print "HIHIIII"  
                           
             try:              try:
                 text +=x.encode('utf-8')                  text +=x
             except:              except:
                   text = x
               
           
   
                 try:                  try:
                     text =x.encode('utf-8')              if text[len(text)-1]==";":
                   text=text[0:len(text)-1]
             
                   
                 except:                  except:
                     text=x.decode('latin-1').encode('utf-8')              pass
                   
         #delete separator (;) if  is there is one          if text=='':
               text2=text
           else:
               text2=re.sub(r';([^\s])','; \g<1>',text)
   
           #teste ob ergebnis leer und header dann nehme title
           
           if (text2=='') and (field=='WEB_project_header'):
               return self.getContent('WEB_title')
   
           if filter:
               splitted=text2.split("""<p class="picture">""")
               if len(splitted)>1:
                   tmp=splitted[1].split("</p>")
                   #return repr(splitted[1])
         try:          try:
             if text[len(text)-1]==";":                          self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
                 text=text[0:len(text)-1].encode('utf-8')  
         except:          except:
             """nothing"""                          self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
                           
         return text                  split2="</p>".join(tmp[1:])
   
                   text3=splitted[0]+split2
   
                   splitted=text3.split("""<p class="picturetitle">""")
                   if len(splitted)>1:
                       tmp=splitted[1].split("</p>")
                       self.imagecap=tmp[0].encode('utf-8')
                   
                       split4="".join(tmp[1:])
   
                       text5=splitted[0]+split4
                   else:
                       #keine caption
                       text5=text3
               else:
                   #kein bild
                   text5=text2
           else:
               text5=text2
   
           #teste ob WEB_project_description und keine führenden p tags
           if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
               text5= "<p>"+text5+"</p>"
   
   
           #filter image
           
   
           return text5.encode('utf-8')
   
       def showImagesOfPage(self,imageUrl=None):
           """show Images of project"""
           self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
           return pt()
   
           
     def show_html(self):      def show_html(self):
         """simple index"""          """simple index"""
         #return "HI"          #return "HI"
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_index.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_index.zpt')).__of__(self)
         return pt()          return pt()
   
       def saveFromPreview(self):
           """save content aus preview"""
           self.WEB_project_description=self.previewTemplate.WEB_project_description[0:]
           self.REQUEST.RESPONSE.redirect("./index.html")
           
       def saveEditedContent(self,kupu=None,preview=None):
           """save Edited content"""
   
           if preview:
               kupu=preview
           #find content of body tags
           start=kupu.find("<body>")
           end=kupu.find("</body>")
           newcontent= kupu[start+6:end]
           
           if preview:
               
               return self.preview(newcontent)
   
           self.copyObjectToArchive()
           self.WEB_project_description=newcontent[0:]
   
           self.REQUEST.RESPONSE.redirect("./index.html")
           
           return True
   
       security.declareProtected('View management screens','edit')
       def edit(self,western=None):
           """Edit pages"""
           if western:
               self.REQUEST.RESPONSE.setCookie("MP_debug_code","western",path="/")
   
               
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProjectNeu.zpt')).__of__(self)
           return pt()
       
       edit_MPIWGProject_main = PageTemplateFile('zpt/edit_MPIWGProject_main', globals())
   
       def getPathStyle(self, path, selected, style=""):
           """returns a string with the given style + 'sel' if path == selected."""
   
           if path == selected:
               return style + 'sel'
           else:
               return style    
   
       def preview(self,description):
           """preview"""
           tmpPro=getattr(self,"previewTemplate",None)
           if not tmpPro:
               tmpPro=MPIWGProject("previewTemplate")
               self._setObject("previewTemplate",tmpPro)
           for field in definedFields:
               setattr(tmpPro,field,getattr(self,field))
           tmpPro.WEB_project_description=description[0:]
           tmpPro.invisible=True
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','previewFrame.zpt')).__of__(self)
           return pt()
   
           #return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"/previewTemplate")
           
   
       def getWebProject_description(self):
           """get description"""
           debug= self.REQUEST.cookies.get("MP_debug_code",None)
           
           if debug and debug=="western":
               return """
               <html>
               <head>
               <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
               </head>
               <body>%s
               </html></body>
               """%self.WEB_project_description[0]
           
           return """
               <html>
               <head>
               <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
               </head>
               <body>%s
               </html></body>
               """%self.getContent('WEB_project_description')
           
           
           
     def editMPIWGProjectForm(self):      def editMPIWGProjectForm(self):
         """editform"""          """editform"""
         pt=PageTemplateFile('Products/MPIWGWeb/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 editMPIWGProject(self,RESPONSE=None):  
         """edit the project"""  
                   
         #return self.REQUEST      def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
           """edit the project and archive the old version"""
           
           self.copyObjectToArchive() # archive the object
   
   
         for x in definedFields:          for x in definedFields:
             if self.REQUEST.has_key(x):              if self.REQUEST.has_key(x):
                                   
                 setattr(self,x,[self.REQUEST[x].decode('utf-8')])                  setattr(self,x,[self.REQUEST[x].decode('utf-8')])
                           
           if self.REQUEST.has_key('active'):
               self.setActiveFlag(True)
           else:
               self.setActiveFlag(False)
           if fromEdit and (RESPONSE is not None):
               RESPONSE.redirect('./editMPIWGBasisEditor')
   
           else:
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
   
       security.declareProtected('View managment screens','editMPIWGDisciplinesThemesEditor')
       def editMPIWGDisciplinesThemesEditor(self):
           """edit from edit"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemesNeu.zpt')).__of__(self)
           return pt()
           
       
     def editMPIWGDisciplinesThemesForm(self):      def editMPIWGDisciplinesThemesForm(self):
         """edit the disciplines and themes Form"""          """edit the disciplines and themes Form"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGDisciplinesThemes.zpt').__of__(self)       
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemes.zpt')).__of__(self)
         return pt()          return pt()
   
     def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None):      def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None,fromEdit=None):
         """edit disciplin and form"""          """edit disciplin and form"""
         if disciplines:          if disciplines:
             if type(disciplines) is StringType:              if type(disciplines) is StringType:
Line 795  class MPIWGProject(Folder): Line 2339  class MPIWGProject(Folder):
         else:          else:
             self.xdata_10=""              self.xdata_10=""
                           
           if fromEdit and (RESPONSE is not None):
               RESPONSE.redirect('./editMPIWGDisciplinesThemesEditor')
   
           else:
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def isChecked(self,wert,list):      def isChecked(self,wert,list):
         """check if wert is in ; seperated list"""          """check if wert is in ; seperated list"""
         print "W:",wert  
         print "L:",list,type(list)  
         #felder sind manchmnal als liste mit einem element definiert          #felder sind manchmnal als liste mit einem element definiert
         if type(list) is StringType or UnicodeType:           if type(list) is StringType or UnicodeType: 
             splitted=list.split(";")              splitted=list.split(";")
         else:          else:
             splitted=list[0].split(";")              splitted=list[0].split(";")
   
         print splitted          splitted=[y.rstrip().lstrip() for y in splitted]
           
         for x in splitted:          for x in splitted:
               x=re.sub(r"[^A-z ]","",x)
             if (not x==u'') and x in wert:              if (not x==u'') and x in wert:
                 return 1                  return 1
         return 0          return 0
           
       security.declareProtected('View management screens','editMPIWGBasisEditor')
       def editMPIWGBasisEditor(self):
           """editform"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)
           return pt()
   
       security.declareProtected('View management screens','editMPIWGBasisForm')
     def editMPIWGBasisForm(self):      def editMPIWGBasisForm(self):
         """editform"""          """editform"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGBasis.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)
         return pt()          return pt()
   
       security.declareProtected('View management screens','editMPIWGRelatedPublicationsForm')
     def editMPIWGRelatedPublicationsForm(self):      def editMPIWGRelatedPublicationsForm(self):
         """Edit related Publications"""          """Edit related Publications"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGRelatedPublications.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)
         return pt()          return pt()
                   
           
     def loadNewFileForm(self):      def loadNewFileForm(self):
         """Neues XML-File einlesen"""          """Neues XML-File einlesen"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_newfile.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_newfile.zpt')).__of__(self)
         return pt()          return pt()
   
     def loadNewFile(self,RESPONSE=None):      def loadNewFile(self,RESPONSE=None):
Line 855  class MPIWGProject(Folder): Line 2413  class MPIWGProject(Folder):
   
 def manage_addMPIWGProjectForm(self):  def manage_addMPIWGProjectForm(self):
     """form for adding the project"""      """form for adding the project"""
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGProjectForm.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_addMPIWGProject(self,id,RESPONSE=None):  def manage_addMPIWGProject(self,id,RESPONSE=None):
     """method to add a project"""      """method to add a project"""
     #print argv      #print argv
     if self.REQUEST.has_key('fileupload'):      fileupload=self.REQUEST.get('fileupload',None)
         fileupload=self.REQUEST['fileupload']  
         if fileupload:          if fileupload:
   
             file_name=fileupload.filename              file_name=fileupload.filename
             filedata=fileupload.read()              filedata=fileupload.read()
   
Removed from v.1.14  
changed lines
  Added in v.1.47.2.57

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