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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.37 and 1.47.2.58

version 1.37, 2004/10/14 09:01:32 version 1.47.2.58, 2006/08/15 13:28:29
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  from Globals import package_home
 import urllib  import urllib
 import MPIWGStaff  import MPIWGStaff
Line 13  import string Line 19  import string
 import re  import re
 import os  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:
Line 33  def sortF(x,y): Line 78  def sortF(x,y):
         try:          try:
             return cmp(str(x[1]),str(y[1]))              return cmp(str(x[1]),str(y[1]))
         except:                     except:           
             print "error",x[1],y[1]              
             return 0               return 0 
           
 def sortI(x,y):  def sortI(x,y):
Line 58  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):  class MPIWGTemplate(ZopePageTemplate):
     """Create a layout Template for different purposes"""      """Create a layout Template for different purposes"""
   
     meta_type="MPIWGTemplate"      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):      def __init__(self, id, text=None, content_type=None,MPIWGType=None):
         self.id = str(id)          self.id = str(id)
   
Line 78  class MPIWGTemplate(ZopePageTemplate): Line 223  class MPIWGTemplate(ZopePageTemplate):
           
         """change form"""          """change form"""
   
       def isActiveItem(self):
           """teste ob ausgewaehlt"""
           if self.absolute_url()==self.REQUEST['URL']:
               return "aktiv"
           else:
               return ""
   
 def manage_addMPIWGTemplateForm(self):  def manage_addMPIWGTemplateForm(self):
     """Form for adding"""      """Form for adding"""
Line 87  def manage_addMPIWGTemplateForm(self): Line 238  def manage_addMPIWGTemplateForm(self):
 from urllib import quote  from urllib import quote
   
   
 def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,REQUEST=None):  def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):
     "Add a Page Template with optional file content."      "Add a Page Template with optional file content."
     if type(MPIWGType)==StringType:      if type(MPIWGType)==StringType:
         MPIWGTypes=[MPIWGType]          MPIWGTypes=[MPIWGType]
Line 122  def manage_addMPIWGTemplate(self, MPIWGT Line 273  def manage_addMPIWGTemplate(self, MPIWGT
             except AttributeError:              except AttributeError:
                 u = REQUEST['URL1']                  u = REQUEST['URL1']
   
       ob = getattr(self, id)
       ob.weight=weight
                           
     REQUEST.RESPONSE.redirect(u+'/manage_main')      REQUEST.RESPONSE.redirect(u+'/manage_main')
     return ''      return ''
Line 133  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):      def upDateSQL(self,fileName):
         """updates SQL databases using fm.jar"""          """updates SQL databases using fm.jar"""
         fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')          fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')
         xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)          xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)
           zLOG.LOG("MPIWG Web",zLOG.INFO,"java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath))
         os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()          ret=os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()
           zLOG.LOG("MPIWG Web",zLOG.INFO,"result convert: %s"%ret)
         return 1          return 1
           
     def patchProjects(self,RESPONSE):      def patchProjects(self,RESPONSE):
Line 160  class MPIWGRoot(ZSQLExtendFolder): Line 473  class MPIWGRoot(ZSQLExtendFolder):
                           
     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):      def redirectIndex_html(self,request):
         #return request['URL1']+'/index_html'          #return request['URL1']+'/index_html'
                   
Line 238  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 286  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 317  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 353  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 388  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 412  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":
    
               ret.sort(sortStopWords(self))
               
         else:          else:
             ret.sort(sortF)              ret.sort(sortF)
                   
Line 426  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 434  class MPIWGRoot(ZSQLExtendFolder): Line 795  class MPIWGRoot(ZSQLExtendFolder):
           
                   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Update Personal Homepages','action':'updateHomepages'},          {'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 463  class MPIWGRoot(ZSQLExtendFolder): Line 825  class MPIWGRoot(ZSQLExtendFolder):
                     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 updateHomepages(self,RESPONSE):      def updatePublicationDB(self,personId=None):
         """lege members an"""          """updates the publication db, i.e. copy year into the main table"""
           
           if personId:
               founds = self.ZSQLInlineSearch(_table="publications",id_main=personId)
           else:
               founds = self.ZSQLInlineSearch(_table="publications")
               
           for found in founds:
                           
               if found.id_institutsbibliographie and (not found.id_institutsbibliographie =="") and (not found.id_institutsbibliographie =="0"):
                   
                   entries = self.ZSQLInlineSearch(_table="institutsbiblio",id=found.id_institutsbibliographie)
                   for entry in entries:
                       self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)
                       
               if found.id_gen_bib and (not found.id_gen_bib ==""):
                   entries = self.ZSQLInlineSearch(_table="bibliography",id=found.id_gen_bib)
                   for entry in entries:
                       self.ZSQLChange(_table='publications',_identify='oid=%s' % found.oid,year=entry.year,referencetype=entry.reference_type)
                       
           return True        
           
       def updateHomepages(self,RESPONSE=None):
           """ 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'}):
           
               username=getTextFromNode(row.xpath('./dn:username',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               id=getTextFromNode(row.xpath('./dn:ID',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               name=getTextFromNode(row.xpath('./dn:Name',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               vorname=getTextFromNode(row.xpath('./dn:Vorname',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               title=getTextFromNode(row.xpath('./dn:Title',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               position=getTextFromNode(row.xpath('./dn:Position',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               e_mail=getTextFromNode(row.xpath('./dn:e_mail',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               e_mail_p=getTextFromNode(row.xpath('./dn:e_mail_p',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               date_from=getTextFromNode(row.xpath('./dn:Date_from',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               date_to=getTextFromNode(row.xpath('./dn:Date_to',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               abteilung=getTextFromNode(row.xpath('./dn:Abteilung',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               heimat_inst=getTextFromNode(row.xpath('./dn:heimat_inst',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               funded_by=getTextFromNode(row.xpath('./dn:funded_by',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               e_mail2=getTextFromNode(row.xpath('./dn:e_mail2',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               publish_the_data=getTextFromNode(row.xpath('./dn:publish_the_data',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               stay_at_mpiwg=getTextFromNode(row.xpath('./dn:stay_at_mpiwg',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0])
               #cwNode=row.xpath('./dn:current_work.current',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0]
               cw=row.xpath('./dn:current_work/dn:DATA',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})
               if cw:
                   txt=getTextFromNode(cw[0])
               else:
                   txt=""
              
               #cwNode=row.xpath('.//dn:current_work.publish',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})[0]
               cw=row.xpath('./dn:current_work/dn:DATA',explicitNss={'dn':'http://www.filemaker.com/fmpdsoresult'})
   
               if cw:
                   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>")
                      
           return True
        
       def reindexCatalogs(self,RESPONSE=None):
           """reindex members and project catalog"""
           
           
           try:
               self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
               self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
           except:
               zLOG.LOG("MPIWG Root (updatehomepage)",zLOG.WARNING," %s %s"%sys.exc_info()[:2])
               
           
       
           
              
           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')          self.upDateSQL('personalwww.xml')
         founds=self.ZSQLInlineSearch(_table='personal_www')          founds=self.ZSQLInlineSearch(_table='personal_www',publish_the_data='yes')
         project=getattr(self,'members')          project=getattr(self,'members')
         for found in founds:          for found in founds:
                           
Line 486  class MPIWGRoot(ZSQLExtendFolder): Line 1011  class MPIWGRoot(ZSQLExtendFolder):
   
   
                                           
           #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:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
                   
   #    def getAllMembers(self,reset=None):
   #        """give list of all members"""
   #        ret=[]
   #
   #
   #        if reset or (getattr(self,'_v_membersList',None) is None):
   #            for member in self.members._objects:
   #                if member['meta_type']=='MPIWGStaff':
   #                    memberObj=getattr(self.members,member['id'])
   #                    if memberObj.isPublished():
   #                           ret.append(memberObj.title.decode('utf-8'))
   #            
   #            ret.sort()
   #            self._v_membersList=ret[0:]
   #        print ret
   #  
   #        return self._v_membersList
   
     def getAllMembers(self):      def getAllMembers(self):
         """give list of all members"""          #ret=[]
         ret=[]  
   
         #for x in self.members.objectValues('MPIWGStaff'):          results=self.MembersCatalog({'isPublished':True})
             #print x.title  
         #    ret.append(x.title.decode('utf-8'))  
   
         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):          ret=[", ".join([proj.lastName, proj.firstName]).decode('utf-8') for proj in results]
                                ret.append(x[1].title.decode('utf-8'))  
                           
         ret.sort()          ret.sort()
         #print ret  
     
         return ret          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 523  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 535  class MPIWGRoot(ZSQLExtendFolder): Line 1090  class MPIWGRoot(ZSQLExtendFolder):
                     #title=project[0].WEB_title                      #title=project[0].WEB_title
                     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):      def formatElementForOverview(self,element):
         """format the element for output in overview"""          """format the element for output in overview"""
Line 548  class MPIWGRoot(ZSQLExtendFolder): Line 1162  class MPIWGRoot(ZSQLExtendFolder):
                 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'))                  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":              if element[3].getContent('xdata_05') == "5":
                 return """<h2 class="hier"><a href="%s">Ind. Research Group II: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))                  return """<h2 class="hier"><a href="%s">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'))              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'))
   
Line 598  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 669  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 =="Otto Sibum" : person="H. Otto Sibum"
             if person =="Norton Wise" : person="M. Norton Wise"              if person =="Norton Wise" : person="M. Norton Wise"
                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))                      #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
Line 679  class MPIWGRoot(ZSQLExtendFolder): Line 1306  class MPIWGRoot(ZSQLExtendFolder):
                     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"""
Line 700  class MPIWGRoot(ZSQLExtendFolder): Line 1329  class MPIWGRoot(ZSQLExtendFolder):
         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
Line 717  class MPIWGRoot(ZSQLExtendFolder): Line 1347  class MPIWGRoot(ZSQLExtendFolder):
         if proj:          if proj:
             proj2=[]              proj2=[]
             for x in proj:              for x in proj:
                                if (not getattr(x.getObject(),'invisible',None)) and (getattr(x.getObject(),'archiveTime','')==''):
                 if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):                  if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):
                          
                        #print repr(splitted[1]),repr(splitted[0]),repr(x.WEB_title)  
                        proj2.append(x)                         proj2.append(x)
         #    proj2.sort(sortP)  
         #    ret.append((y,proj2))  
         else:          else:
             proj2=[]              proj2=[]
                           
Line 731  class MPIWGRoot(ZSQLExtendFolder): Line 1358  class MPIWGRoot(ZSQLExtendFolder):
         if proj:          if proj:
             names=[x.WEB_title for x in proj]              names=[x.WEB_title for x in proj]
             for x in proj:              for x in proj:
                 if not x.WEB_title in names:                  
                   if (not x.WEB_title in names) and (getattr(x.getObject(),'archiveTime','')==''):
                     proj2.append(x)                      proj2.append(x)
   
   
Line 753  class MPIWGRoot(ZSQLExtendFolder): Line 1381  class MPIWGRoot(ZSQLExtendFolder):
         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 816  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 874  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 894  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 index_html(self):      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"""          """show homepage"""
     ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])          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:          if ext:
             return getattr(self,ext[0][1].getId())()              return getattr(self,ext.getId())()
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)    
   
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/project_main').__of__(self)  
         return pt()          return pt()
   
       
     def getDataFields(self):      def getDataFields(self):
         """giveListofDatafields"""          """giveListofDatafields"""
         ret=[]          ret=[]
Line 924  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:  
                 try:  
                     text =x.encode('utf-8')  
                 except:                  except:
                     text=x.decode('latin-1').encode('utf-8')                  text = x
               
           
                   
         #delete separator (;) if  is there is one  
         ## try:  
 ##             print text, text[len(text)-1]  
 ##         except:  
 ##             print "error:",text  
         try:          try:
             if text[len(text)-1]==";":              if text[len(text)-1]==";":
                 text=text[0:len(text)-1]                  text=text[0:len(text)-1]
                       
                                   
         except:          except:
             """nothing"""              pass
   
           if text=='':
               text2=text
           else:
         text2=re.sub(r';([^\s])','; \g<1>',text)          text2=re.sub(r';([^\s])','; \g<1>',text)
   
         #teste ob ergebnis leer und header dann nehme title          #teste ob ergebnis leer und header dann nehme title
                   
         if (text2=='') and (field=='WEB_project_header'):          if (text2=='') and (field=='WEB_project_header'):
             return self.getContent('WEB_title')              return self.getContent('WEB_title')
   
           if filter:
               splitted=text2.split("""<p class="picture">""")
               if len(splitted)>1:
                   tmp=splitted[1].split("</p>")
                   #return repr(splitted[1])
                   try:
                           self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
                   except:
                           self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
                   
                   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          #teste ob WEB_project_description und keine führenden p tags
         if (len(text2)>4) and (not text2[0:3]=='<p>') and (field=='WEB_project_description'):          if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
             return "<p>"+text2+"</p>"              text5= "<p>"+text5+"</p>"
         #if text2=="Otto Sibum":  
         #text2="H. Otto Sibum"  
         return text2          #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()
   
       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()          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 1011  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 1071  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):
Line 1079  def manage_addMPIWGProject(self,id,RESPO Line 2421  def manage_addMPIWGProject(self,id,RESPO
     #print argv      #print argv
     fileupload=self.REQUEST.get('fileupload',None)      fileupload=self.REQUEST.get('fileupload',None)
     if fileupload:      if fileupload:
         print fileupload  
         file_name=fileupload.filename          file_name=fileupload.filename
         filedata=fileupload.read()          filedata=fileupload.read()
                   
Removed from v.1.37  
changed lines
  Added in v.1.47.2.58

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