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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.9 and 1.47.2.4

version 1.9, 2004/06/28 18:47:14 version 1.47.2.4, 2005/05/27 06:47:19
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
   
 """  """
 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.ZCatalog.CatalogPathAwareness import CatalogAware
   from Globals import package_home
   import urllib
 import MPIWGStaff  import MPIWGStaff
 import string  import string
 import re  import re
   import os
 from types import *  from types import *
   import zLOG
 import xmlhelper # Methoden zur Verwaltung der projekt xmls  import xmlhelper # Methoden zur Verwaltung der projekt xmls
 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 bibliography import *
   import time
   
 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']
   
Line 25  def sortF(x,y): Line 33  def sortF(x,y):
     try:      try:
         return cmp(x[1],y[1])          return cmp(x[1],y[1])
     except:      except:
           try:
               return cmp(str(x[1]),str(y[1]))
           except:           
               
         return 0          return 0
           
 def sortI(x,y):  def sortI(x,y):
Line 49  def sortI(x,y): Line 61  def sortI(x,y):
     except:      except:
         return cmp(x[1],y[1])          return cmp(x[1],y[1])
   
   class MPIWGTemplate(ZopePageTemplate):
       """Create a layout Template for different purposes"""
   
       meta_type="MPIWGTemplate"
   
       manage_options=ZopePageTemplate.manage_options+(
           {'label':'Change Weight','action':'changeWeightForm'},
           )
   
       def changeWeightForm(self):
           """change weight form"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGTemplateChangeWeight.zpt')).__of__(self)
           return pt()
   
       def changeWeight(self,weight,RESPONSE=None):
           """change weight"""
           self.weight=weight
           if RESPONSE is not None:
               RESPONSE.redirect('manage')
   
           
       def __init__(self, id, text=None, content_type=None,MPIWGType=None):
           self.id = str(id)
   
   
   
           self.ZBindings_edit(self._default_bindings)
           if text is None:
               self._default_content_fn = os.path.join(package_home(globals()),
                                                  'zpt/MPIWG_%s_template_standard.zpt'%MPIWGType)
               text = open(self._default_content_fn).read()
           self.pt_edit(text, content_type)
   
       
           """change form"""
   
       def isActive(self):
           """teste ob ausgewaehlt"""
           if self.absolute_url()==self.REQUEST['URL']:
               return "aktiv"
           else:
               return ""
   
   def manage_addMPIWGTemplateForm(self):
       """Form for adding"""
       pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGTemplate.zpt')).__of__(self)
       return pt()
   
   from urllib import quote
   
   
   def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,weight=0,REQUEST=None):
       "Add a Page Template with optional file content."
       if type(MPIWGType)==StringType:
           MPIWGTypes=[MPIWGType]
       else:
           MPIWGTypes=MPIWGType
           
       for singleType in MPIWGTypes:
   
           
 class MPIWGRoot(Folder):          if REQUEST is None:
               self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))
               ob = getattr(self, id)
               
               if title:
                   ob.pt_setTitle(title)
               return ob
           else:
               file = REQUEST.form.get('file')
               headers = getattr(file, 'headers', None)
               if headers is None or not file.filename:
                   zpt = MPIWGTemplate(id,MPIWGType=singleType)
               else:
                   zpt = MPIWGTemplate(id, file, headers.get('content_type'))
   
               self._setObject(id, zpt)
               ob = getattr(self, id)
               if title:
                   ob.pt_setTitle(title)
   
               try:
                   u = self.DestinationURL()
               except AttributeError:
                   u = REQUEST['URL1']
   
       ob = getattr(self, id)
       ob.weight=weight
       
       REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
       
   class MPIWGRoot(ZSQLExtendFolder):
     """Stammordner für den Web-Server"""      """Stammordner für den Web-Server"""
   
     fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',      fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',
Line 61  class MPIWGRoot(Folder): Line 165  class MPIWGRoot(Folder):
              '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 getValue(self,field):      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 subNav(self,id):
           """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 hasattr(self,id):
               subs=self.ZopeFind(getattr(self,id),obj_metatypes=['MPIWGTemplate'])
               subs.sort(sortWeight)
               return subs
           else:
               return None
       def isActive(self,name):
           """teste ob subnavigation aktiv"""
           for part in self.REQUEST['URL'].split("/"):
               if part==name:
                   return True
           return False
           
           
       def upDateSQL(self,fileName):
           """updates SQL databases using fm.jar"""
           fmJarPath=os.path.join(package_home(globals()), 'updateSQL/fm.jar')
           xmlPath=os.path.join(package_home(globals()), "updateSQL/%s"%fileName)
           zLOG.LOG("MPIWG Web",zLOG.INFO,"java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath))
           ret=os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()
       zLOG.LOG("MPIWG Web",zLOG.INFO,"result convert: %s"%ret)
           return 1
       
       def patchProjects(self,RESPONSE):
           """patch"""
           projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
           for project in projects:
           tmp=project[1].WEB_project_description[0].replace("/CD/projects/","")[0:]
                   setattr(project[1],'WEB_project_description',[tmp[0:]])
                   RESPONSE.write("<p>%s</p>\n"%project[0])
               
       def replaceNotEmpty(self,format,field):
           """replace not empty"""
           if field and (not field.lstrip()==''):
               return format%field
           else:
               return ""
           
   
       def isActual(self,project):
           """checke if project is actual"""
           actualTime=time.localtime()
           obj= project.getObject()
           
           if getattr(obj,'archiveTime',actualTime)< actualTime:
               return False
           else:
               return True
           
       def redirectIndex_html(self,request):
           #return request['URL1']+'/index_html'
           
           return urllib.urlopen(request['URL1']+'/index_html').read()
   
       
       def formatBibliography(self,here,found):
           """format"""
           return formatBibliography(here,found)
       
       def getValue(self,fieldStr):
         """Inhalt des Feldes"""          """Inhalt des Feldes"""
   
         if type(field)==StringType:          if type(fieldStr)==StringType:
               field=fieldStr
           else:
               field=fieldStr[0]
             try:              try:
                 if field[len(field)-1]==";":                  if field[len(field)-1]==";":
                     field=field[0:len(text)-1]                  field=field[0:len(field)-1]
             except:              except:
                     """nothing"""  
                           
               """nothing"""
           field=re.sub(r';([^\s])','; \g<1>',field)
             return field.encode('utf-8')              return field.encode('utf-8')
                   
         else:  
             return field[0].encode('utf-8')  
   
           
     def sortedNames(self,list):      def sortedNames(self,list):
         """sort names"""          """sort names"""
   
         def sortLastName(x,y):          def sortLastName(x_c,y_c):
               try:
                   x=urllib.unquote(x_c).encode('utf-8','ignore')
               except:
                   x=urllib.unquote(x_c)
   
               try:
                   y=urllib.unquote(y_c).encode('utf-8','ignore')
               except:
                   x=urllib.unquote(y_c)
                   
   
               
             try:              try:
                 last_x=x.split()[len(x.split())-1]                  last_x=x.split()[len(x.split())-1]
                 last_y=y.split()[len(y.split())-1]                  last_y=y.split()[len(y.split())-1]
Line 112  class MPIWGRoot(Folder): Line 306  class MPIWGRoot(Folder):
         self.id=id          self.id=id
         self.title=title          self.title=title
                   
       def urlQuote(self,str):
           """quote"""
           return urllib.quote(str)
   
       def urlUnQuote(self,str):
           """quote"""
           return urllib.unquote(str)
       
     def harvestHistoricalPersons(self):      def harvestHistoricalPersons(self):
         """erstelle liste aller erwaehnten actors"""          """erstelle liste aller erwaehnten actors"""
   
Line 130  class MPIWGRoot(Folder): Line 332  class MPIWGRoot(Folder):
             lg=len(project[1].xdata_03[0])-1              lg=len(project[1].xdata_03[0])-1
   
             if (lg>1) and (project[1].xdata_03[0][lg]==";"):              if (lg>1) and (project[1].xdata_03[0][lg]==";"):
                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg-1]                  project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]
   
                       
             
Line 140  class MPIWGRoot(Folder): Line 342  class MPIWGRoot(Folder):
                     for person in project[1].xdata_03[0].split(";"):                      for person in project[1].xdata_03[0].split(";"):
                         personNormal=normalize(person)                          personNormal=normalize(person)
                         if personNormal in list.keys():                          if personNormal in list.keys():
                             list[personNormal].append(project[1])                              list[urllib.quote(personNormal)][1].append(project[1])
                         else:                          else:
                             list[personNormal]=[project[1]]                              list[urllib.quote(personNormal)]=(personNormal,[project[1]])
                 else: #guess , is sepeator                  else: #guess , is sepeator
                     for person in project[1].xdata_03[0].split(","):                      for person in project[1].xdata_03[0].split(","):
                         personNormal=normalize(person)                          personNormal=normalize(person)
                         if personNormal in list.keys():                          if urllib.quote(personNormal) in list.keys():
                             list[personNormal].append(project[1])                              list[urllib.quote(personNormal)][1].append(project[1])
                         else:                          else:
                             list[personNormal]=[project[1]]                              list[urllib.quote(personNormal)]=(personNormal,[project[1]])
   
             except:              except:
                 print "ERROR",project                  zLOG.LOG("MPIWG Web (harvestHistoricalPerson)",zLOG.ERROR,"cannot annalyize: %s"%repr(project))
   
                                   
         return list          return list
   
Line 161  class MPIWGRoot(Folder): Line 364  class MPIWGRoot(Folder):
         self.personDict={}          self.personDict={}
         personDict=self.harvestHistoricalPersons()          personDict=self.harvestHistoricalPersons()
         for person in personDict.keys():          for person in personDict.keys():
             for project in personDict[person]:              for project in personDict[person][1]:
                 if person in self.personDict.keys():                  if person in self.personDict.keys():
                     self.personDict[person].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))                      self.personDict[person][1].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))
                 else:                  else:
                     self.personDict[person]=[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])]                      self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect("showHistoricalPersons")              RESPONSE.redirect("showHistoricalPersons")
                           
   
       def getPersonDict(self,name):
           """name von dict"""
   
           try:
               return self.personDict[name][0].encode('utf-8')
           except:
               return self.personDict[name][0]
               return self.personDict[name][0].decode('latin-1').encode('utf-8')
           
   
     def showHistoricalPersons(self):      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):
Line 195  class MPIWGRoot(Folder): Line 408  class MPIWGRoot(Folder):
   
     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 236  class MPIWGRoot(Folder): Line 450  class MPIWGRoot(Folder):
                 if re.match(searchStr,project[1]):                  if re.match(searchStr,project[1]):
                                           
                     if depth:                      if depth:
                         print "ho"  
                         if int(depth)>=len(project[1].split("."))-len(childs.split(".")):                          if int(depth)>=len(project[1].split("."))-len(childs.split(".")):
                                           
                             ret.append(project)                              ret.append(project)
Line 244  class MPIWGRoot(Folder): Line 458  class MPIWGRoot(Folder):
                         ret.append(project)                          ret.append(project)
         return ret          return ret
           
     def getProjectFields(self,fieldName,folder=None,sort=None):      def getProjectFields(self,fieldName,actual="yes",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'):              
                 #print obj.meta_type              if (not getattr(obj,'invisible',None)) and (obj.isActual()):
                 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 268  class MPIWGRoot(Folder): Line 480  class MPIWGRoot(Folder):
                                           
                     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)
Line 290  class MPIWGRoot(Folder): Line 499  class MPIWGRoot(Folder):
           
                   
     manage_options = Folder.manage_options+(      manage_options = Folder.manage_options+(
         {'label':'Import Persons','action':'importNamesForm'},          {'label':'Update Personal Homepages','action':'updateHomepages'},
         {'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'},
Line 298  class MPIWGRoot(Folder): Line 507  class MPIWGRoot(Folder):
           
     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 310  class MPIWGRoot(Folder): Line 519  class MPIWGRoot(Folder):
                           
                           
             splitted=line.split(",")              splitted=line.split(",")
             print splitted             # print splitted
                   
             if not (splitted[0]==""):              if not (splitted[0]==""):
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])                  newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])
                                   
                 try:                  try:
                     project._setObject(splitted[0],newObj)                      project._setObject(splitted[0],newObj)
                     print "done:",splitted[0]                      #print "done:",splitted[0]
                   except:
                       zLOG.LOG("MPIWG Web (importNames)",zLOG.INFO,"cannot import: %s"%splitted[0])
   
                       
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def updateHomepages(self,RESPONSE):
           """lege members an"""
           
           self.upDateSQL('personalwww.xml')
           founds=self.ZSQLInlineSearch(_table='personal_www',publish_the_data='yes')
           project=getattr(self,'members')
           for found in founds:
               
               if not (found.e_mail==""):
                   newObj=MPIWGStaff.MPIWGStaff(found.username,found.name,found.vorname)
                   
                   try:
                       project._setObject(found.username,newObj)
                       RESPONSE.write("<p>new:%s</p>\n"%found.username)
                   except:
                       RESPONSE.write("<p>old:%s (%s,%s)</p>\n"%(found.username,found.name,found.vorname))
   
   
           #delete non existing
   
   
           foundUserNames=[x.username for x in founds]
           for member in self.ZopeFind(self,obj_metatypes=["MPIWGStaff"],search_sub=1):            
               
               if member[1].getId() not in foundUserNames:
                   member[1].aq_parent.manage_delObjects(ids=[member[1].getId()])
                   RESPONSE.write("<p>deleted:%s</p>\n"%member[1].getId())
           try:
               self.MembersCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
                 except:                  except:
                     print "not done:",splitted[0]              pass
           self.ProjectCatalog.manage_catalogReindex(self.REQUEST,RESPONSE,self.REQUEST['URL1'])
       
                                           
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
           
     def getAllMembers(self):      def getAllMembers(self):
         """give list of all members"""          """give list of all members"""
         ret=[]          ret=[]
Line 335  class MPIWGRoot(Folder): Line 583  class MPIWGRoot(Folder):
         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):          for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):
                                ret.append(x[1].title.decode('utf-8'))                                 ret.append(x[1].title.decode('utf-8'))
                           
         #ret.sort()          ret.sort()
         #print ret          #print ret
       
         return ret          return ret
Line 361  class MPIWGRoot(Folder): Line 609  class MPIWGRoot(Folder):
         """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"): # 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(".")
                     depth=len(splittedId)                      depth=len(splittedId)
                     nr=idNr                      nr=idNr
                     title=project[0].WEB_title                      #title=project[0].WEB_title
                                           title=[project[0].getContent('WEB_title')]
                       #print title
                     returnList.append((depth,nr,title,project[0]))                      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"""
                   else:
                       for i in range(element[0]-actualDepth):
                           ret+="</li>\n<li><ul>\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></li>\n"
   
                   if element[0]==1:
                       department=int(element[3].getContent('xdata_05'))-1
                       
                       ret+="""</div>\n"""
                       ret+="""<div class="bildspalte"><img src="../grafik/dept%i.jpg" width="160" height="120" vspace="40"></div>
                       <div class="dept">\n<ul>\n
                       """%department
               
                   actualDepth=element[0]
               else:
                   ret+="""</li>\n"""
               ret+="""<li>\n"""
               
               if actualDepth==1:
                   departmentName={'1':'Department I','2':'Department II','3':'Department III', '4':'NWG','5':'NWG'} 
                   department=element[3].getContent('xdata_05')
                   ret+="""<img src="../grafik/totop.gif" vspace="10" border="0"></a><br><a name="dept%s"></a>%s: """%(department,departmentName[department])
   
               ret+="""<a href="%s">%s</a>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
           return ret
       
       def formatElementForOverview(self,element):
           """format the element for output in overview"""
           if element[0]==1: #department
               #print element[3].getContent('xdata_05')
               if element[3].getContent('xdata_05') == "4":
                   return """<h2 class="hier"><a href="%s">Ind. Research Group I: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
               if element[3].getContent('xdata_05') == "5":
                   return """<h2 class="hier"><a href="%s">Ind. Research Group II: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
               
               return """<h2 class="hier"><a href="%s">Department %s: %s</a></h2>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('xdata_05'),element[3].getContent('WEB_title'))
   
           elif element[0]==2: #mainprojects
               return """<h3 class="hier"><a href="%s">%s</a></h3><p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
   
           elif element[0]==3:
               return """<p class="hier"><a href="%s">%s</a></p>"""%(element[3].absolute_url()+"/index.html",element[3].getContent('WEB_title'))
   
           
     def changePosition(self,treeId,select,RESPONSE=None):      def changePosition(self,treeId,select,RESPONSE=None):
         """Change Postion Entry"""          """Change Postion Entry"""
         numbers=[]          numbers=[]
Line 430  class MPIWGRoot(Folder): Line 740  class MPIWGRoot(Folder):
                   
                           
                   
       def getRelativeUrlFromPerson(self,list):
           """get urls to person list"""
           ret=[]
           persons=list.split(";")
           for person in persons:
               
               if len(person)>1: #nicht nur Trennzeichen
                   splitted=person.split(",")
                   if len(splitted)==1:
                       splitted=person.split(" ")
                   splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
                   if splittedNew[0]=='':
                       del splittedNew[0]
                   search=string.join(splittedNew,' AND ')
                   
                   if not search=='':
   
                       try:
                           proj=self.MembersCatalog({'title':search})
                       except:
                           proj=None
   
                   if proj:
                       #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
                       ret.append("<a href=%s >%s</a>"%('members/'+proj[0].id+'/index.html',person))
                   else:
                       #ret.append("%s"%person.encode('utf-8'))
                       ret.append("%s"%person)
           return string.join(ret,";")
                   
                           
     def getUrlFromPerson(self,list):      def getUrlFromPerson(self,list):
Line 441  class MPIWGRoot(Folder): Line 780  class MPIWGRoot(Folder):
             if len(person)>1: #nicht nur Trennzeichen              if len(person)>1: #nicht nur Trennzeichen
                 splitted=person.split(",")                  splitted=person.split(",")
                 if len(splitted)==1:                  if len(splitted)==1:
                     splitted=person.split(" ")                      splitted=person.lstrip().rstrip().split(" ")
                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]                  splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]
                 if splittedNew[0]=='':                  if splittedNew[0]=='':
                     del splittedNew[0]                      del splittedNew[0]
Line 455  class MPIWGRoot(Folder): Line 794  class MPIWGRoot(Folder):
                         proj=None                          proj=None
   
                 if proj:                  if proj:
                     ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person))              if person =="Otto Sibum" : person="H. Otto Sibum"
               if person =="Norton Wise" : person="M. Norton Wise"
                       #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))
                       ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url+"/index.html",person))
                 else:                  else:
                       #ret.append("%s"%person.encode('utf-8'))
                     ret.append("%s"%person)                      ret.append("%s"%person)
         return string.join(ret,";")          return string.join(ret,";")
                                                     
Line 466  class MPIWGRoot(Folder): Line 809  class MPIWGRoot(Folder):
         members=self.getAllMembers()          members=self.getAllMembers()
         #return str(members)          #return str(members)
         for x in members:          for x in members:
             y=x.encode('utf-8')              ret+=self.getProjectsOfMember(name=x)
             splitted=y.split(",")              
           return ret
   
       def getProjectsOfMember(self,name=None,email=None):
           """get project of a member"""
           def sortP(x,y):
               """sort by sorting number"""
               #print x.xdata_05,y.xdata_05
               return cmp(x.WEB_title,y.WEB_title)
           
          
           ret=[]
             splitNeu=[]              splitNeu=[]
             for s in splitted:          if email:
               print "IIII:",self.getId()
               members=self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff'],obj_ids=[email],search_sub=1)
               name =  members[0][1].title.decode('utf-8')
                   
                 splitNeu.append("\""+s+"\"")          y=name
           splitted=y.split(",")
           #XXXX
           splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]
           
           #for s in splitted:
           #    splitNeu.append("\""+s+"\"")
                 search=string.join(splitNeu,' AND ')                  search=string.join(splitNeu,' AND ')
           
                 proj=self.ProjectCatalog({'xdata_01':search})                  proj=self.ProjectCatalog({'xdata_01':search})
                           
             print "Search:",search,"Found:",proj  
             if proj:              if proj:
                 ret.append((y,proj))              proj2=[]
               for x in proj:
   
                   if not getattr(x.getObject(),'invisible',None):
                       if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):
                          proj2.append(x)
   
             else:              else:
                 ret.append((y,None))              proj2=[]
               
           proj=self.ProjectCatalog({'xdata_08':search})
           if proj:
               names=[x.WEB_title for x in proj]
               for x in proj:
   
                   if not x.WEB_title in names:
                       proj2.append(x)
   
   
           proj2.sort(sortP)
   
           if len(proj2)>0:
               ret.append((y,proj2))
   
         return ret          return ret
        
     def givePersonList(self,name):      def givePersonList(self,name):
         """check if person is in personfolder and return list of person objects"""          """check if person is in personfolder and return list of person objects"""
                   
         splitted=name.split(",")          splitted=name.split(",")
         if len(splitted)==1:          if len(splitted)==1:
             splitted=name.split(" ")              splitted=name.lstrip().rstrip().split(" ")
         splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]          splittedNew=[split.lstrip() for split in splitted]
           
         if splittedNew[0]=='':          if splittedNew[0]=='':
             del splittedNew[0]              del splittedNew[0]
         search=string.join(splittedNew,' AND ')          search=string.join(splittedNew,' AND ')
Line 559  class MPIWGRoot(Folder): Line 945  class MPIWGRoot(Folder):
                   
 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(CatalogAware,Folder):
     """Class for Projects"""      """Class for Projects"""
   
     meta_type='MPIWGProject'      meta_type='MPIWGProject'
       default_catalog='ProjectCatalog'
       
       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 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 632  class MPIWGProject(Folder): Line 1075  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 checkDate(self,date):
           """teste ob zum Zeitpunkt date eine andere version existierte"""
           
   
           def sortProjectsByTime(x,y):
               return cmp(x[1].archiveTime,y[1].archiveTime)
           
           finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
           if not finds:
               return self.absolute_url()
           else:
               finds.sort(sortProjectsByTime)
   
           for find in finds:
               if int(find[1].archiveTime) > int(date):
                   return find[1].absolute_url()
   
           return self.absolute_url()
           
               
               
       def index_html(self):
           """show homepage"""
           
           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']))
           else:
               self.REQUEST.SESSION['MPI_redirected']=None
           
       ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
   
           if ext:
               return getattr(self,ext[0][1].getId())()
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(self)
           return pt()
   
       
     def getDataFields(self):      def getDataFields(self):
         """giveListofDatafields"""          """giveListofDatafields"""
         ret=[]          ret=[]
         for x in range(1,14):          for x in range(1,14):
               if not x in [6,10,9]: # not used fields
             ret.append('xdata_%02i'%x)              ret.append('xdata_%02i'%x)
         return ret          return ret
                           
Line 650  class MPIWGProject(Folder): Line 1135  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="ERROR"                  text = x
               
           
                   
         #delete separator (;) if  is there is one  
         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
                           
         return text          if text=='':
               text2=text
           else:
               text2=re.sub(r';([^\s])','; \g<1>',text)
   
           #teste ob ergebnis leer und header dann nehme title
           
           if (text2=='') and (field=='WEB_project_header'):
               return self.getContent('WEB_title')
   
           if filter:
               splitted=text2.split("""<p class="picture">""")
               tmp=splitted[1].split("</p>")
               self.REQUEST.SESSION['image']=tmp[0].split("\"")[1].encode('utf-8')
               split2="</p>".join(tmp[1:])
   
               text3=splitted[0]+split2
   
               splitted=text3.split("""<p class="picturetitle">""")
               tmp=splitted[1].split("</p>")
               print tmp
               self.REQUEST.SESSION['imagecap']=tmp[0].encode('utf-8')
               split4="".join(tmp[1:])
   
               text5=splitted[0]+split4
               
           else:
               text5=text2
   
           #teste ob WEB_project_description und keine führenden p tags
           if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
               return "<p>"+text5+"</p>"
   
   
           #filter image
           
         
           return text5.encode('utf-8')
           
     def show_html(self):      def show_html(self):
         """simple index"""          """simple index"""
         #return "HI"          #return "HI"
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_index.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_index.zpt')).__of__(self)
         return pt()          return pt()
   
     def 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):      def editMPIWGProject(self,RESPONSE=None):
         """edit the project"""          """edit the project and archive the old version"""
           
           self.copyObjectToArchive() # archive the object
   
                   
         #return self.REQUEST  
         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 RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     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):
Line 727  class MPIWGProject(Folder): Line 1251  class MPIWGProject(Folder):
   
     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  
         for x in splitted:          for x in splitted:
             if (not x==u'') and x in wert:              if (not x==u'') and x in wert:
                 return 1                  return 1
Line 743  class MPIWGProject(Folder): Line 1266  class MPIWGProject(Folder):
           
     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()
     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 781  class MPIWGProject(Folder): Line 1304  class MPIWGProject(Folder):
   
 def manage_addMPIWGProjectForm(self):  def manage_addMPIWGProjectForm(self):
     """form for adding the project"""      """form for adding the project"""
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGProjectForm.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_addMPIWGProject(self,id,RESPONSE=None):  def manage_addMPIWGProject(self,id,RESPONSE=None):
     """method to add a project"""      """method to add a project"""
     #print argv      #print argv
     if self.REQUEST.has_key('fileupload'):      fileupload=self.REQUEST.get('fileupload',None)
         fileupload=self.REQUEST['fileupload']  
         if fileupload:          if fileupload:
   
             file_name=fileupload.filename              file_name=fileupload.filename
             filedata=fileupload.read()              filedata=fileupload.read()
   
Removed from v.1.9  
changed lines
  Added in v.1.47.2.4

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