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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.5 and 1.44

version 1.5, 2004/03/10 09:17:31 version 1.44, 2005/03/01 10:03:51
Line 1 Line 1
 """This files contains the class MPIWG Projects"""  """This contains the class MPIWG Projects
   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 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 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']
   
 checkFields = ['xdata_01']  checkFields = ['xdata_01']
   
 def sortF(x,y):  
           
   
   def sortF(x,y):
       try:
     return cmp(x[1],y[1])      return cmp(x[1],y[1])
       except:
           try:
               return cmp(str(x[1]),str(y[1]))
           except:           
               print "error",x[1],y[1]
               return 0 
   
 def sortI(x,y):  def sortI(x,y):
     xsplit=x[1].split(".")      xsplit=x[1].split(".")
Line 42  def sortI(x,y): Line 59  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"
   
       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"""
   
           
 class MPIWGRoot(Folder):  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,REQUEST=None):
       "Add a Page Template with optional file content."
       if type(MPIWGType)==StringType:
           MPIWGTypes=[MPIWGType]
       else:
           MPIWGTypes=MPIWGType
           
       for singleType in MPIWGTypes:
   
   
           if REQUEST is None:
               self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))
               ob = getattr(self, id)
               
               if title:
                   ob.pt_setTitle(title)
               return ob
           else:
               file = REQUEST.form.get('file')
               headers = getattr(file, 'headers', None)
               if headers is None or not file.filename:
                   zpt = MPIWGTemplate(id,MPIWGType=singleType)
               else:
                   zpt = MPIWGTemplate(id, file, headers.get('content_type'))
   
               self._setObject(id, zpt)
               ob = getattr(self, id)
               if title:
                   ob.pt_setTitle(title)
   
               try:
                   u = self.DestinationURL()
               except AttributeError:
                   u = REQUEST['URL1']
   
               
       REQUEST.RESPONSE.redirect(u+'/manage_main')
       return ''
   
       
   class MPIWGRoot(ZSQLExtendFolder):
     """Stammordner für den Web-Server"""      """Stammordner für den Web-Server"""
   
     folders=['MPIWGProject','Folder']      fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',
                'xdata_03':'Historical Persons','xdata_04':'Time period',
                'xdata_05':'Sorting number','xdata_06':'Keywords','xdata_07':'Short title',
                'xdata_08':'Other involved scholars' ,'xdata_09':'Part of','xdata_10':'Covered by',
                'xdata_11':'Object Digitallibrary','xdata_12':'Cooperation partners',
                'xdata_13':'Funding institutions','WEB_project_header':'WEB_project_header',
                'WEB_project_description':'WEB_project_description','WEB_related_pub':'WEB_related_pub'}
       
       folders=['MPIWGProject','Folder','ECHO_Navigation']
     meta_type='MPIWGRoot'      meta_type='MPIWGRoot'
           
       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 redirectIndex_html(self,request):
           #return request['URL1']+'/index_html'
           
           return urllib.urlopen(request['URL1']+'/index_html').read()
   
       
       def formatBibliography(self,here,found):
           """format"""
           return formatBibliography(here,found)
       
       def getValue(self,fieldStr):
           """Inhalt des Feldes"""
           
           if type(fieldStr)==StringType:
               field=fieldStr
           else:
               field=fieldStr[0]
           try:
               if field[len(field)-1]==";":
                   field=field[0:len(field)-1]
           except:
   
               """nothing"""
           field=re.sub(r';([^\s])','; \g<1>',field)
           return field.encode('utf-8')
   
   
       
       def sortedNames(self,list):
           """sort names"""
   
           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:
                   last_x=x.split()[len(x.split())-1]
                   last_y=y.split()[len(y.split())-1]
   
               except:
   
                   last_x=""
                   last_y=""
               
               
               
               if last_x<last_y:
                   return 1
               elif last_x>last_y:
                   return -1
               else:
                   return 0
               
           list.sort(sortLastName)
           list.reverse()
           
           return list
       
     def __init__(self, id, title):      def __init__(self, id, title):
         """init"""          """init"""
         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):
           """erstelle liste aller erwaehnten actors"""
   
           def normalize(str):
               """loesche fuhrendes space"""
               if (len(str)>1) and (str[0]==" "):
                   ret=str[1:]
               else:
                   ret=str
               return ret
           
           list={}
           projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])
           
           for project in projects:
               lg=len(project[1].xdata_03[0])-1
   
               if (lg>1) and (project[1].xdata_03[0][lg]==";"):
                   project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]
   
             
        
                   
               try:
                   if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;
                       for person in project[1].xdata_03[0].split(";"):
                           personNormal=normalize(person)
                           if personNormal in list.keys():
                               list[urllib.quote(personNormal)][1].append(project[1])
                           else:
                               list[urllib.quote(personNormal)]=(personNormal,[project[1]])
                   else: #guess , is sepeator
                       for person in project[1].xdata_03[0].split(","):
                           personNormal=normalize(person)
                           if urllib.quote(personNormal) in list.keys():
                               list[urllib.quote(personNormal)][1].append(project[1])
                           else:
                               list[urllib.quote(personNormal)]=(personNormal,[project[1]])
   
               except:
                   print "ERROR",project
                   
           return list
   
       def storeHistoricalPersons(self,RESPONSE=None):
           """store persons"""
           self.personDict={}
           personDict=self.harvestHistoricalPersons()
           for person in personDict.keys():
               for project in personDict[person][1]:
                   if person in self.personDict.keys():
                       self.personDict[person][1].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))
                   else:
                       self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])
   
           if RESPONSE is not None:
               RESPONSE.redirect("showHistoricalPersons")
               
   
       def getPersonDict(self,name):
           """name von dict"""
   
           try:
               return self.personDict[name][0].encode('utf-8')
           except:
               return self.personDict[name][0]
               return self.personDict[name][0].decode('latin-1').encode('utf-8')
           
   
       def showHistoricalPersons(self):
           """show persons"""
           pt=PageTemplateFile('Products/MPIWGWeb/zpt/showHistoricalPersons').__of__(self)
           return pt()
   
           
       def editHistoricalPersonsForm(self):
           """edit historical persons for consistency"""
           pt=PageTemplateFile('Products/MPIWGWeb/zpt/editHistoricalPersonsForm').__of__(self)
           return pt()
   
       def getProjectsByFieldContent(self,fieldName,fieldContentsEntry):
           """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""
           if type(fieldContentsEntry) is StringType:
               fieldContents=[fieldContentsEntry]
           else:
               fieldContents=fieldContentsEntry
               
           projects=self.ProjectCatalog({fieldName:string.join(fieldContents,' OR')})
           #print projects
           return projects
   
       def changeMPIWGRootForm(self):
           """edit"""
           pt=PageTemplateFile('Products/MPIWGWeb/zpt/changeMPIWGRootForm').__of__(self)
           return pt()
   
       def changeMPIWGRoot(self,title,disciplineList,themesList,RESPONSE=None):
           """change"""
           self.title=title
           self.disciplineList=disciplineList
           self.themesList=themesList
   
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
       def getDisciplineList(self):
           """get disciplines as list"""
           return self.disciplineList.split("\n")
       
       def getThemeList(self):
           """get themes as list"""
           return self.themesList.split("\n")
       
       def test(self):
           """test"""
           return self.getProjectsByFieldContent('xdata_09',['biology'])[0].absolute_url
   
       def getContexts(self,childs=None,parents=None,depth=None):
           """childs alle childs, alle parents"""
           ret=[]
           if parents:
               splitted=parents.split(".")
               parentId=string.join(splitted[0:len(splitted)-1],".")
           
               for project in self.getProjectFields('xdata_05',sort='int'):
                   if project[1]==parentId:
                       ret.append(project)
   
           if childs:
               for project in self.getProjectFields('xdata_05',sort='int'):
                   searchStr=childs+"(\..*)"
                   if re.match(searchStr,project[1]):
                       
                       if depth:
   
                           if int(depth)>=len(project[1].split("."))-len(childs.split(".")):
                       
                               ret.append(project)
                       else:
                           ret.append(project)
           return ret
       
     def getProjectFields(self,fieldName,folder=None,sort=None):      def getProjectFields(self,fieldName,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):
                 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 78  class MPIWGRoot(Folder): Line 411  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 100  class MPIWGRoot(Folder): Line 430  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':'Edit Historical Persons','action':'editHistoricalPersonsForm'},
           {'label':'Store Historical Persons','action':'storeHistoricalPersons'},
         )          )
           
     def importNamesForm(self):      def importNamesForm(self):
Line 111  class MPIWGRoot(Folder): Line 444  class MPIWGRoot(Folder):
     def importNames(self,fileupload,folderName,RESPONSE=None):      def importNames(self,fileupload,folderName,RESPONSE=None):
         """import komma-sep list email,lastName,firstName"""          """import komma-sep list email,lastName,firstName"""
         project=getattr(self,folderName)          project=getattr(self,folderName)
           load=fileupload.read()
           
           for line in load.split('\r'):
               
                   
         for line in fileupload.readlines():  
             #print line  
             splitted=line.split(",")              splitted=line.split(",")
              # 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]
                 except:                  except:
                     print "not done:",splitted[0]                      print "not done:",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())
   
           self.MembersCatalog.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=[]
   
         for x in self.members.objectValues('MPIWGStaff'):          #for x in self.members.objectValues('MPIWGStaff'):
             #print x.title              #print x.title
             ret.append(x.title)          #    ret.append(x.title.decode('utf-8'))
   
           for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):
                                  ret.append(x[1].title.decode('utf-8'))
                           
         ret.sort()          ret.sort()
           #print ret
     
         return ret          return ret
   
       def printAllMembers(self):
           """prin"""
           members=self.getAllMembers()
           ret=""
           for x in members:
               ret+="<p>%s</p>"%x
           return ret
       
           
     def makeList(self,entry):      def makeList(self,entry):
         """makes a list out of one entry or repeat a list"""          """makes a list out of one entry or repeat a list"""
         if type(entry) is StringType:          if type(entry) is StringType:
Line 147  class MPIWGRoot(Folder): Line 537  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 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=[]
   
         # Suche hoechste bisherige nummer          # Suche hoechste bisherige nummer
         projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05          projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05
           #print "pj",projects
         for project in projects: #suche alle subtrees der treeId          for project in projects: #suche alle subtrees der treeId
             #print treeId              #print treeId
                           
Line 173  class MPIWGRoot(Folder): Line 586  class MPIWGRoot(Folder):
                     try:                      try:
                         numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))                          numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))
                     except:                      except:
                         numbers.append(0)                          numbers.append(int(0))
         numbers.sort()  
         highest=int(numbers[len(numbers)-1])          try:
               highest=max(numbers)
           except:
               highest=0
         projects=self.showNewProjects()          projects=self.showNewProjects()
         for i in self.makeList(select):          for i in self.makeList(select):
             highest+=10              highest+=10
Line 211  class MPIWGRoot(Folder): Line 627  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 219  class MPIWGRoot(Folder): Line 664  class MPIWGRoot(Folder):
         persons=list.split(";")          persons=list.split(";")
         for person in persons:          for person in persons:
                           
               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]
             search=string.join(splittedNew,' AND ')              search=string.join(splittedNew,' AND ')
                   
             if not search=='':              if not search=='':
                                   
                 try:                  try:
Line 234  class MPIWGRoot(Folder): Line 681  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 243  class MPIWGRoot(Folder): Line 694  class MPIWGRoot(Folder):
         """give tuple member /projects"""          """give tuple member /projects"""
         ret=[]          ret=[]
         members=self.getAllMembers()          members=self.getAllMembers()
           #return str(members)
         for x in members:          for x in members:
             splitted=x.split(",")              ret+=self.getProjectsOfMember(name=x)
               
           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=[]
           if email:
               #print "IIII:",self.getId()
               members=self.ZopeFind(self,obj_metatypes=['MPIWGStaff'],obj_ids=[email],search_sub=1)
               name =  members[0][1].title.decode('utf-8')
   
           y=name
           splitted=y.split(",")
           #XXXX
           splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]
           
           #for s in splitted:
           #    splitNeu.append("\""+s+"\"")
           search=string.join(splitNeu,' AND ')
           
           proj=self.ProjectCatalog({'xdata_01':search})
                           
             proj=self.ProjectCatalog({'xdata_01':string.join(splitted,' AND')})  
             if proj:              if proj:
               ret.append((x,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:
               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 325  class MPIWGRoot(Folder): Line 829  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('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)
Line 344  class MPIWGProject(Folder): Line 849  class MPIWGProject(Folder):
   
     meta_type='MPIWGProject'      meta_type='MPIWGProject'
   
   
       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"""
         splitted=self.WEB_project_description[0].split()          splitted=self.WEB_project_description[0].split()
Line 386  class MPIWGProject(Folder): Line 943  class MPIWGProject(Folder):
         self.title=id          self.title=id
         if argv:          if argv:
             for arg in definedFields:              for arg in definedFields:
           try:
                 setattr(self,arg,argv[arg])                  setattr(self,arg,argv[arg])
           except:
               setattr(self,arg,"")
         else:          else:
             for arg in definedFields:              for arg in definedFields:
                 setattr(self,arg,'')                  setattr(self,arg,'')
Line 396  class MPIWGProject(Folder): Line 956  class MPIWGProject(Folder):
         {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},          {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
         {'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':'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('Products/MPIWGWeb/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 423  class MPIWGProject(Folder): Line 1026  class MPIWGProject(Folder):
             #print "HIHIIII"              #print "HIHIIII"
                           
             try:              try:
                 text +=x                  text +=x.encode('utf-8')
             except:              except:
                 try:                  try:
                     text =x                      text =x.encode('utf-8')
                 except:                  except:
                     text="ERROR"                      text=x.decode('latin-1').encode('utf-8')
         #print "TEXT",text.encode('ascii','ignore')            
         return text          #delete separator (;) if  is there is one
           ## try:
   ##             print text, text[len(text)-1]
   ##         except:
   ##             print "error:",text
           try:
               if text[len(text)-1]==";":
                   text=text[0:len(text)-1]
             
                   
           except:
               """nothing"""
   
           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')
   
           #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'):
               return "<p>"+text2+"</p>"
           #if text2=="Otto Sibum":
           #text2="H. Otto Sibum"
           return text2
           
     def show_html(self):      def show_html(self):
         """simple index"""          """simple index"""
Line 443  class MPIWGProject(Folder): Line 1070  class MPIWGProject(Folder):
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)          pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)
         return pt()          return pt()
   
     def editMPIWGBasisForm(self):  
         """editform"""  
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGBasis.zpt').__of__(self)  
         return pt()  
     def editMPIWGRelatedPublicationsForm(self):  
         """Edit related Publications"""  
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGRelatedPublications.zpt').__of__(self)  
         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]])                  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):
           """edit the disciplines and themes Form"""
           pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGDisciplinesThemes.zpt').__of__(self)
           return pt()
   
       def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None):
           """edit disciplin and form"""
           if disciplines:
               if type(disciplines) is StringType:
                   self.xdata_09=disciplines
               else:
                   self.xdata_09=string.join(disciplines,";")
           else:
                   self.xdata_09=""
           if themes:
               if type(themes) is StringType:
                   self.xdata_10=themes
               else:
                   self.xdata_10=string.join(themes,";")
           else:
               self.xdata_10=""
               
           if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
   
   
       def isChecked(self,wert,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
           if type(list) is StringType or UnicodeType: 
               splitted=list.split(";")
           else:
               splitted=list[0].split(";")
   
           print splitted
           for x in splitted:
               if (not x==u'') and x in wert:
                   return 1
           return 0
       
       def editMPIWGBasisForm(self):
           """editform"""
           pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGBasis.zpt').__of__(self)
           return pt()
       def editMPIWGRelatedPublicationsForm(self):
           """Edit related Publications"""
           pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGRelatedPublications.zpt').__of__(self)
           return pt()
           
                   
     def loadNewFileForm(self):      def loadNewFileForm(self):
         """Neues XML-File einlesen"""          """Neues XML-File einlesen"""
Line 501  def manage_addMPIWGProjectForm(self): Line 1174  def manage_addMPIWGProjectForm(self):
 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:
           print fileupload
             file_name=fileupload.filename              file_name=fileupload.filename
             filedata=fileupload.read()              filedata=fileupload.read()
   
Removed from v.1.5  
changed lines
  Added in v.1.44

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