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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.39 and 1.47.2.100

version 1.39, 2004/10/21 14:28:09 version 1.47.2.100, 2008/09/03 21:52:14
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
   
   $author dwinter   - last change  26.06.2008
   
 """  """
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 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 Products.MPIWGBibliography.BibliographyManager import BibliographyManager
   from OFS.Image import Image
 from Globals import package_home  from Globals import package_home
 import urllib  import urllib
 import MPIWGStaff  
 import string  
 import re  import re
 import os  import os
 from types import *  from types import *
   import logging
 import xmlhelper # Methoden zur Verwaltung der projekt xmls  import xmlhelper # Methoden zur Verwaltung der projekt xml
 from OFS.SimpleItem import SimpleItem  from OFS.SimpleItem import SimpleItem
 from OFS.Folder import Folder  from OFS.Folder import Folder
   from OFS.Image import Image
   from AccessControl import ClassSecurityInfo
 from bibliography import *  from bibliography import *
   import time
   #import xml.dom.minidom
   import sys
   #from Ft.Xml.XPath import Evaluate
   #from Ft.Xml.XPath.Context import Context
   #from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
   #from Ft.Xml import EMPTY_NAMESPACE
   #import copy
   #import updatePersonalWWW
   
 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']  #import MPIWGStaff
   
 checkFields = ['xdata_01']  from MPIWGHelper import *
   
   import MPIWGRoot
   import MPIWGLink
   import MPIWGTemplate
   
   # die folgenden Klassen sind jetzt in einzelne Files ausgelagert aus Kompatibilitaetsgruenden, bleiben die Klassen hier noch drin.
   # Sonst funktionieren die alten Webseiten nicht mehr.
   
 def sortF(x,y):  class MPIWGRoot(MPIWGRoot.MPIWGRoot):
     try:      """depricated"""
         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):  class MPIWGLink(MPIWGLink.MPIWGLink):
     xsplit=x[1].split(".")      """depricated"""
     ysplit=y[1].split(".")  
     xret=""  
     yret=""  
     try:  
         for i in range(5):  
             try:  
                 yret=yret+"%04i"%int(xsplit[i])  
             except:  
                 yret=yret+"%04i"%0  
   
             try:  class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
                 xret=xret+"%04i"%int(ysplit[i])      """depricated"""
             except:  
                 xret=xret+"%04i"%0  
                                   
   class MPIWGProject_publication(Folder):
       """publications object fuer project"""
                   
         return cmp(int(yret),int(xret))      meta_type="MPIWGProject_publication"
     except:  
         return cmp(x[1],y[1])  
   
 class MPIWGTemplate(ZopePageTemplate):      def editPublication(self,text=None,image1=None,image2=None,description=None,RESPONSE=None):
     """Create a layout Template for different purposes"""          """edit a publication"""
   
     meta_type="MPIWGTemplate"          if (not text) and (not description):
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
               return pt()
   
     def __init__(self, id, text=None, content_type=None,MPIWGType=None):  
         self.id = str(id)  
   
           self.text=text[0:]
           self.description=description
   
           if image1:
               if hasattr(self,'publicationImage1'):
                   self.publicationImage1.manage_upload(image1)
               else:
                   nO = Image('publicationImage1','',image1)
                   self._setObject('publicationImage1',nO)
   
         self.ZBindings_edit(self._default_bindings)          if image2:
         if text is None:              if hasattr(self,'publicationImage2'):
             self._default_content_fn = os.path.join(package_home(globals()),                  self.publicationImage2.manage_upload(image2)
                                                'zpt/MPIWG_%s_template_standard.zpt'%MPIWGType)              else:
             text = open(self._default_content_fn).read()                  nO = Image('publicationImage2','',image2)
         self.pt_edit(text, content_type)                  self._setObject('publicationImage2',nO)
   
           
         """change form"""          if RESPONSE:
               RESPONSE.redirect("../managePublications")
   
   class MPIWGProject_image(Image):
       """Images for Projects"""
   
 def manage_addMPIWGTemplateForm(self):      meta_type="MPIWGProject_image"
     """Form for adding"""  
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGTemplate.zpt')).__of__(self)      def showImage(self,imageUrl=None):
           """show Images at an extra page"""
           self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
     return pt()      return pt()
   
 from urllib import quote      def editImage(self,file=None,caption=None,RESPONSE=None):
           """edit the Image"""
           if (not file) and (not caption):
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_imageForm.zpt')).__of__(self)
               return pt()
   
           if file and (not file.filename.lstrip().rstrip()==""):
               self.manage_upload(file)
   
 def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,REQUEST=None):          if caption:
     "Add a Page Template with optional file content."              self.caption=caption[0:]
     if type(MPIWGType)==StringType:  
         MPIWGTypes=[MPIWGType]  
     else:  
         MPIWGTypes=MPIWGType  
                   
     for singleType in MPIWGTypes:          if RESPONSE:
               RESPONSE.redirect("../manageImages")
   
   class MPIWGProject(CatalogAware,Folder):
       """Class for Projects"""
   
         if REQUEST is None:  
             self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))  
             ob = getattr(self, id)  
                           
             if title:      security=ClassSecurityInfo()
                 ob.pt_setTitle(title)      meta_type='MPIWGProject'
             return ob      default_catalog='ProjectCatalog'
         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)      def decode(self,str):
             ob = getattr(self, id)          """return unicode object"""
             if title:          return unicodify(str)
                 ob.pt_setTitle(title)  
   
             try:      def sortedByPlace(self,metatype):
                 u = self.DestinationURL()          """find metatype and sort by place"""
             except AttributeError:          def sort(x,y):
                 u = REQUEST['URL1']              return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
           founds=self.ZopeFind(self,obj_metatypes=[metatype]);
                           
     REQUEST.RESPONSE.redirect(u+'/manage_main')          founds.sort(sort)
     return ''  
   
           return founds
           
 class MPIWGRoot(ZSQLExtendFolder):  
     """Stammordner für den Web-Server"""  
   
     fieldLabels={'WEB_title':'WEB_Title','xdata_01':'Responsible Scientists','xdata_02':'Department',      def copyPublicationsToList(self,RESPONSE=None):
              'xdata_03':'Historical Persons','xdata_04':'Time period',          """copy publications in to list"""
              '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']          publicationTxt=self.getContent('WEB_related_pub')
     meta_type='MPIWGRoot'  
   
     def upDateSQL(self,fileName):          pubSplits=publicationTxt.split("<p>")
         """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)  
   
         os.popen("java -classpath %s -Djava.awt.headless=true Convert %s"%(fmJarPath,xmlPath),"r").read()          for pubSplit in pubSplits:
               pubSplit=pubSplit.replace("</p>","")
               self.addPublication(pubSplit)
   
         return 1          if RESPONSE:
               RESPONSE.redirect('managePublications')
           
     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==''):  
             return format%field  
         else:  
             return ""  
                   
       def copyImageToMargin(self,RESPONSE=None):  
           """copy inline images to marginal images"""
   
     def redirectIndex_html(self,request):  
         #return request['URL1']+'/index_html'  
                   
         return urllib.urlopen(request['URL1']+'/index_html').read()          #getImages from WEB_project_description
           description=self.getContent('WEB_project_description')
   
           text2=description
           splitted=text2.split("""<p class="picture">""")
           
     def formatBibliography(self,here,found):          imageURLs=[]
         """format"""          imageCaptions=[]
         return formatBibliography(here,found)          for split in  splitted[1:]:
                   tmp=split.split("</p>")
                   #return repr(splitted[1])
           
     def getValue(self,fieldStr):                  try:
         """Inhalt des Feldes"""                          imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
                   except:
                   
         if type(fieldStr)==StringType:  
             field=fieldStr  
         else:  
             field=fieldStr[0]  
         try:          try:
             if field[len(field)-1]==";":                          imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
                 field=field[0:len(field)-1]  
         except:          except:
                           imageURLs.append("")
   
             """nothing"""                  split2="</p>".join(tmp[1:])
         field=re.sub(r';([^\s])','; \g<1>',field)  
         return field.encode('utf-8')  
   
   
                   splitted=split2.split("""<p class="picturetitle">""")
                   if len(splitted)>1:
                       tmp=splitted[1].split("</p>")
                       imageCaptions.append(tmp[0].encode('utf-8'))
           
     def sortedNames(self,list):  
         """sort names"""  
   
         def sortLastName(x_c,y_c):                  else:
             try:                      #keine caption
                 x=urllib.unquote(x_c).encode('utf-8','ignore')  
             except:  
                 x=urllib.unquote(x_c)  
   
             try:                      imageCaptions.append("")
                 y=urllib.unquote(y_c).encode('utf-8','ignore')  
             except:  
                 x=urllib.unquote(y_c)  
                                   
   
           #eintragen:
           for imageURL in imageURLs:
               filename=imageURL.split("/")[-1]
               #lege neues images object an, mit leerem bild
                           
             try:              if self.ZopeFind(self,obj_ids=[filename]):
                 last_x=x.split()[len(x.split())-1]                  #existiert das bild schon, dann neuen filenamen
                 last_y=y.split()[len(y.split())-1]                  filename="project_image_"+filename
   
               self.addImage(None,imageCaptions[imageURLs.index(imageURL)],filename=filename)
               #hole die bilddaten aus der url
               url=self.absolute_url()+"/"+imageURL
               #url=self.absolute_url()+"/"+filename
           
               try:#relative url
                   data=urllib.urlopen(url).read()
               except:
                   try:#absolute
                       data=urllib.urlopen(self.imageURL).read()
             except:              except:
                       logger("MPIWG Project",logging.ERROR,"can't open: %s"%url)
   
                 last_x=""              obj=getattr(self,filename)
                 last_y=""              obj.update_data(data)
                           
           if RESPONSE:
               RESPONSE.redirect('manageImages')
                           
       def manageImages(self,imageName=None,op=None):
           """managage images"""
                           
             if last_x<last_y:  
                 return 1  
             elif last_x>last_y:  
                 return -1  
             else:  
                 return 0  
                           
         list.sort(sortLastName)          if imageName and op:
         list.reverse()              if op=='up':
                   images=self.getImages()
                   for image in images:
                       if image[0]==imageName:
                           nr=images.index(image)
                           if not nr==0:
                               images[nr-1][1].place+=1
                               images[nr][1].place-=1
                           pass
               elif op=='down':
                   images=self.getImages()
                   for image in images:
                       if image[0]==imageName:
                           nr=images.index(image)
                           if not (nr==len(images)-1):
                               images[nr+1][1].place-=1
                               images[nr][1].place+=1
                           pass
                   
         return list  
           
     def __init__(self, id, title):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_manageImagesForm.zpt')).__of__(self)
         """init"""          return pt()
         self.id=id  
         self.title=title  
   
     def urlQuote(self,str):      def managePublications(self,pubName=None,op=None):
         """quote"""          """managage images"""
         return urllib.quote(str)  
   
     def urlUnQuote(self,str):  
         """quote"""  
         return urllib.unquote(str)  
           
     def harvestHistoricalPersons(self):          if pubName and op:
         """erstelle liste aller erwaehnten actors"""              if op=='up':
                   publications=self.getPublications()
                   for publication in publications:
                       if publication[0]==pubName:
                           nr=publications.index(publication)
                           if not nr==0:
                               publications[nr-1][1].place+=1
                               publications[nr][1].place-=1
                           pass
               elif op=='down':
                   publications=self.getPublications()
                   for publication in publications:
                       if publication[0]==pubName:
                           nr=publications.index(publication)
                           if not (nr==len(publications)-1):
                               publications[nr+1][1].place-=1
                               publications[nr][1].place+=1
                           pass
   
         def normalize(str):  
             """loesche fuhrendes space"""          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
             if (len(str)>1) and (str[0]==" "):          return pt()
                 ret=str[1:]      def hasExtendedPublicationList(self):
           """test if extended publication list exists"""
           if not hasattr(self,"publicationList"):
               return False
             else:              else:
                 ret=str              return True
             return ret  
                   
         list={}      def createExtendedPublicationList(self,RESPONSE=None):
         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])          """erzeuge erweiterte publications liste"""
           pl = BibliographyManager("publicationList","","institutsbiblio",self.connection_id)
           self._setObject("publicationList", pl)
                   
         for project in projects:  
             lg=len(project[1].xdata_03[0])-1  
   
             if (lg>1) and (project[1].xdata_03[0][lg]==";"):          zt=ZopePageTemplate('index.html')
                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]          pl._setObject('index.html',zt)
           default_content_fn = os.path.join(package_home(globals()),
                                                 'zpt/showExtendedProjectBibliography.zpt')
           text = open(default_content_fn).read()
           zt.pt_edit(text, 'text/html')
   
                       
           if RESPONSE:
               RESPONSE.redirect("managePublications")
             
       def getPublications(self):
           """get all Publications"""
           def sort_images(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
                                   
             try:          publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
                 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:          publications.sort(sort_images)
                 print "ERROR",project          return publications
                                   
         return list      def addPublication(self,text,RESPONSE=None):
           """add an MPIWG_Publication"""
   
     def storeHistoricalPersons(self,RESPONSE=None):          name="publication_"+str(self.getLastPublicationNumber()+1)
         """store persons"""          
         self.personDict={}          newPublication=MPIWGProject_publication(name)
         personDict=self.harvestHistoricalPersons()  
         for person in personDict.keys():          self._setObject(name,newPublication)
             for project in personDict[person][1]:          obj=getattr(self,name)
                 if person in self.personDict.keys():          obj.text=text[0:]
                     self.personDict[person][1].append((project.absolute_url(),project.WEB_title[0],project.xdata_01[0]))          obj.enabled=True;
                 else:          obj.place=self.getLastPublicationNumber()+1
                     self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])          obj.id=name
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect("showHistoricalPersons")              RESPONSE.redirect('managePublications')
   
                           
       def getLastPublicationNumber(self):
           publications=self.getPublications()
           
           if not publications:
               return 0
           else:
               return getattr(publications[-1][1],'place',0)
   
     def getPersonDict(self,name):      def deletePublication(self,id,RESPONSE=None):
         """name von dict"""              """delete Publication id"""
               self.manage_delObjects([id])
               if RESPONSE:
                   RESPONSE.redirect('managePublications')
   
       def getImages(self):
           """get all Images"""
   
           def sort_images(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
   
           if (getattr(self,'imageURL','')!='') or  (getattr(self,'imagecap','')!='')  :
         try:          try:
             return self.personDict[name][0].encode('utf-8')                  self.addImage(None,getattr(self,'imagecap',''),RESPONSE=None,filename=getattr(self,'imageURL',''))
         except:          except:
             return self.personDict[name][0]                  pass
             return self.personDict[name][0].decode('latin-1').encode('utf-8')              self.imageURL=''
               self.imagecap=''
                   
           images=self.ZopeFind(self,obj_metatypes=['MPIWGProject_image'])
   
     def showHistoricalPersons(self):          images.sort(sort_images)
         """show persons"""          return images
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/showHistoricalPersons').__of__(self)  
         return pt()  
   
       def getLastImageNumber(self):
           images=self.getImages()
                   
     def editHistoricalPersonsForm(self):          if not images:
         """edit historical persons for consistency"""              return 0
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/editHistoricalPersonsForm').__of__(self)          else:
         return pt()              return getattr(images[-1][1],'place',0)
   
     def getProjectsByFieldContent(self,fieldName,fieldContentsEntry):      def deleteImage(self,id,RESPONSE=None):
         """gib alle Projekte aus mit Value von field mit fieldName enthält ein Element der Liste fieldContents"""          """delete Image id"""
         if type(fieldContentsEntry) is StringType:          self.manage_delObjects([id])
             fieldContents=[fieldContentsEntry]          if RESPONSE:
         else:              RESPONSE.redirect('manageImages')
             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:      def hasChildren(self,date=None,onlyActive=1,onlyArchived=1):
             RESPONSE.redirect('manage_main')          """check if project has children"""
           ct=self.getContexts(childs=self.getContent('xdata_05'),
                                    depth=1,date=date,onlyActive=onlyActive)
   
     def getDisciplineList(self):          if ct and len(ct)>0:
         """get disciplines as list"""               return True
         return self.disciplineList.split("\n")          else:
                    return False
     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'):      def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
                 if project[1]==parentId:          """add an MPIWG_Project_image"""
                     ret.append(project)  
           if not filename:
               filename=fileHd.filename
   
         if childs:          if not fileHd:
             for project in self.getProjectFields('xdata_05',sort='int'):              fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
                 searchStr=childs+"(\..*)"  
                 if re.match(searchStr,project[1]):  
                                           
                     if depth:          newImage=MPIWGProject_image(filename,filename,fileHd)
   
                         if int(depth)>=len(project[1].split("."))-len(childs.split(".")):          self._setObject(filename,newImage)
           obj=getattr(self,filename)
           obj.caption=caption[0:]
           obj.enabled=True;
           obj.place=self.getLastImageNumber()+1
           obj.id=filename
                                           
                             ret.append(project)          if RESPONSE is not None:
               RESPONSE.redirect('manageImages')
   
       def PrincipiaSearchSource(self):
           """Return cataloguable key for ourselves."""
           return str(self)
   
       def versionHeader(self):
           """version Header, gibt header text entsprechend der aktuellen version aus"""
           
           actualTime=time.localtime()
           retTXT="""<h2>This is an outdated version, for the actual version please refer to <a href="%s">%s</a></h2>"""
           s=self.aq_parent.absolute_url()
           #print getattr(self,'archiveTime',actualTime)
           if getattr(self,'archiveTime',actualTime)< actualTime:
               return retTXT%(s,s)
                     else:                      else:
                         ret.append(project)              return ""
         return ret  
           
     def getProjectFields(self,fieldName,folder=None,sort=None):      def getActualVersion(self,date=None):
         """getListofFieldNames"""          """actuelle version"""
         ret=[]          def sortProjectsByTime(x,y):
               return cmp(x[1].archiveTime,y[1].archiveTime)
   
           if not date:
               if self.isActual():
                   return self
               else:
                   return None
           
         objects=self.ZopeFind(self,obj_metatypes=['MPIWGProject'],search_sub=1)          #suche ob aeltere versionen vorhanden sind
   
           finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
           if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
               ad=getattr(self,'creationTime','20050101000000')
               if int(date)>int(ad):
                   return self
               else:
                   return None
                                   
         for object in objects:  
             obj=object[1]  
             if fieldName=="WEB_title_or_short":  
                                               
                 if len(obj.getContent('xdata_07'))<3: # hack weil z.Z. manchmal noch ein Trennzeichen ; oder , im Feld statt leer  
                     fieldNameTmp="WEB_title"  
                 else:                  else:
                     fieldNameTmp="xdata_07"              finds.sort(sortProjectsByTime)
   
           for find in finds:
               #gehe durch die alten Projekte und finde das entprechende
               if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
                   return find[1]
   
           #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
           ad=getattr(self,'creationTime','20050101000000')
           
           if int(date)>int(ad):
           
               return self
             else:              else:
                 fieldNameTmp=fieldName              return None
                                           
             ret.append((obj,obj.getContent(fieldNameTmp)))  
   
       def isActual(self):
           """gibt 1 zurueck wenn aktuell, 0 sonst"""
           actualTime=time.localtime()
                   
         if sort=="int":          
             ret.sort(sortI)          #print getattr(self,'archiveTime',actualTime)
           if getattr(self,'archiveTime',actualTime)< actualTime:
               return 0
         else:          else:
             ret.sort(sortF)              return 1
                   
         return ret      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 showNewProjects(self):      def versionManage(self,invisible=None,RESPONSE=None):
         projects=[]          """version Manage form:currently only set to invisible"""
         for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets          self.invisible=invisible
             if objs[0].xdata_05[0] == "":  
                                   
                 projects.append(objs)          if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                                   
         return projects  
           
       def crossLinker(self):
           """experimental crosslinker"""
           splitted=self.WEB_project_description[0].split()
           new=[]
           for split in splitted:
               try:
                   found=self.DescriptionCatalog({'fulltext':split})
                   
     manage_options = Folder.manage_options+(                  if len(found)>1:
         {'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):                      new.append("<a href=%s>%s</a>"%(split,split))
         """Form"""                  else:
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGNamesForm.zpt').__of__(self)                      new.append(split)
         return pt()              except:
                   new.append(split)
           return " ".join(new)
   
     def importNames(self,fileupload,folderName,RESPONSE=None):  
         """import komma-sep list email,lastName,firstName"""  
         project=getattr(self,folderName)  
         load=fileupload.read()  
                   
         for line in load.split('\r'):  
                           
                           
             splitted=line.split(",")      def generateTemplate(self,RESPONSE=None):
            # print splitted          """Erzeuge Template fuer defined fields not_used"""
                   
             if not (splitted[0]==""):          id="index_html"
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])          title=id
           if self._getOb('index_html'):
               self._delObject('index_html')
                                   
                 try:  
                     project._setObject(splitted[0],newObj)  
                     #print "done:",splitted[0]  
                 except:  
                     print "not done:",splitted[0]  
                                           
           newObj=ZopePageTemplate(id,'TEXT')
           self._setObject(id,newObj)
           #self.manage_addPageTemplate(id,title)
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def updateHomepages(self,RESPONSE):      def __init__(self, id, argv=None):
         """lege members an"""          """initiere classe"""
           
         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==""):          self.creationTime=time.strftime("%Y%m%d%H%M%S",time.localtime())[0:]
                 newObj=MPIWGStaff.MPIWGStaff(found.username,found.name,found.vorname)          self.id=id
           self.title=id
           self.isActiveFlag=True #Flag is true is the project is still active, False if accomplished
           self.responsibleScientistsList=[] # enthaelt die Lister der verantwortlichen Wissenschaftler in der Form (NAME, KEY), key ist "" flass Wissenschaftler nicht an unserem Haus
                                   
           if argv:
               for arg in definedFields:
                 try:                  try:
                     project._setObject(found.username,newObj)                          setattr(self,arg,argv[arg])
                     RESPONSE.write("<p>new:%s</p>\n"%found.username)  
                 except:                  except:
                     RESPONSE.write("<p>old:%s (%s,%s)</p>\n"%(found.username,found.name,found.vorname))                          setattr(self,arg,"")
           else:
               for arg in definedFields:
                   setattr(self,arg,'')
   
       manage_options = Folder.manage_options+(
           {'label':'Load New File','action':'loadNewFileForm'},
           {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},
           {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},
           {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},
           {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},
           {'label':'Versionmanager','action':'versionManageForm'},
           )
   
         #delete non existing  
   
       def isActiveProject(self):
           """check if the project is still active, default is true, set to false is the project is accomplished"""
           return getattr(self,'isActiveFlag',True)
   
         foundUserNames=[x.username for x in founds]      def isArchivedProject(self):
         for member in self.ZopeFind(self,obj_metatypes=["MPIWGStaff"],search_sub=1):                      """check if the project is archived"""
                           
             if member[1].getId() not in foundUserNames:          completed=getattr(self,'completedAt',0)
                 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'])         #completed leer 
           if completed=="" :
               return False;
           if completed == 0:
               return False;
   
           
           return True
                                           
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
       def setActiveFlag(self,status=True):
           """set the active flag"""
           self.isActiveFlag=status
                   
     def getAllMembers(self):      def setCompletedAt(self,date):
         """give list of all members"""          """set the date of completion, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
         ret=[]          #logging.info("DATE:"+repr(date))
           transformedDate=self.transformDate(date);
           #logging.info("transformed"+repr(transformedDate))
           if transformedDate is not None:
               setattr(self,"completedAt",transformedDate)
               return True;
           else:
               return False;
   
         #for x in self.members.objectValues('MPIWGStaff'):      def setStartedAt(self,date):
             #print x.title          """set the date of start, date should be in the form DD.MM.YYYY or MM.YYYY or YYYY"""
         #    ret.append(x.title.decode('utf-8'))          #logging.info("DATE:"+repr(date))
           transformedDate=self.transformDate(date);
           #logging.info("transformed"+repr(transformedDate))
           if transformedDate is not None:
               setattr(self,"startedAt",transformedDate)
               return True;
           else:
               return False;
       def getCompletedAt(self):
           """gibt das transformierte Datum zurueck, an dem das Projekt beendet wurde."""
           date=getattr(self,'completedAt','')
           if date:
               return self.reTransformDate(date);
           else:
               # test ob parent abgeschlossen ist
   
         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):              ct=self.getContexts(parents=self.getContent('xdata_05'),depth=1)
                                ret.append(x[1].title.decode('utf-8'))              if (len(ct)>0): #is there are parent
                           
         ret.sort()                  return ct[0][0].getCompletedAt()
         #print ret              return '';
       
         return ret      def getStartedAt(self):
           """gibt das transformierte Datum zurŸck, an dem Projekt begonnen wurde."""
           date=getattr(self,'startedAt','')
           if date:
               return self.reTransformDate(date);
           else:
               return '';
   
     def printAllMembers(self):      def reTransformDate(self,date):
         """prin"""          """transformiert , transformdate zurueck"""
         members=self.getAllMembers()          year=int(date/10000)
         ret=""          month=int((date-year*10000)/100)
         for x in members:          day=int((date-year*10000-month*100))
             ret+="<p>%s</p>"%x          if (day==0) and (month==0):
         return ret              return """%s"""%year;
           if day==0 :
               return """%s.%s"""%(month,year);
           
           return """%s.%s.%s"""%(day,month,year);
                   
     def makeList(self,entry):  
         """makes a list out of one entry or repeat a list"""  
         if type(entry) is StringType:  
             return [entry]  
         else:  
             return entry  
   
   
     def getTree(self):  
         """generate Tree from project list"""  
         returnList=[]  
         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  
                 if not idNr=="":  
                     splittedId=idNr.split(".")  
                     depth=len(splittedId)  
                     nr=idNr  
                     #title=project[0].WEB_title  
                     title=[project[0].getContent('WEB_title')]  
                     #print title  
                     returnList.append((depth,nr,title,project[0]))  
           
         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):  
         """Change Postion Entry"""  
         numbers=[]  
   
         # Suche hoechste bisherige nummer  
         projects=self.getProjectFields('xdata_05') # get Projects sorted by xdata_05  
         #print "pj",projects  
         for project in projects: #suche alle subtrees der treeId  
             #print treeId  
               
             founds=re.match(treeId+"\.(.*)",project[1].split(";")[0])  
             if founds:  
                 #print "x",founds.group(0),len(founds.group(0).split("."))  
                 if len(founds.group(0).split("."))==len(treeId.split("."))+1: # nur ein punkt mehr, d.h. untere ebene  
                     try:  
                         numbers.append(int(founds.group(0).split(".")[len(founds.group(0).split("."))-1]))  
                     except:  
                         numbers.append(int(0))  
   
       def transformDate(self,date):
           """transformiert ein Datum von DD.MM.YYYY, MM.YYYY,YYYY nach  YYYYMMDD, alle nicht angebebenn Werte
           werden auf 0 gesetzt, es wird null zurŸckgegeben falls das Datum ungueltig ist""" 
      
           if (date==None):
               return None;
           
             
           if (date.lstrip().rstrip()=="" ) :
               return "";
           
           splitted=date.split(".")
           length=len(splitted)
           year=0
           month=0
           day=0
           if length > 3:
               return "";
           if length==3:
               day = int(splitted[0])
           if length>1:
               month=int(splitted[length-2])
           
           if length > 0:
         try:          try:
             highest=max(numbers)                  year = int(splitted[length-1])
         except:          except:
             highest=0                  pass
         projects=self.showNewProjects()  
         for i in self.makeList(select):  
             highest+=10  
             projects[int(i)][0].xdata_05=treeId+"."+str(highest)  
   
          ## logging.info("month:"+(month))
           if not (0<=month<13):
               return None;
   
         if RESPONSE is not None:          if not(0<=day<32):
             RESPONSE.redirect('showTree')              return None;
                   
     def changeTree(self,RESPONSE=None):          if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
         """change the complete tree"""              year=2000+year;
         form=self.REQUEST.form          return year*10000+month*100+day
         hashList={}  
         fields=self.getTree()  
   
                   
         for idNr in form.keys():  
             fields[int(idNr)][3].xdata_05=form[idNr]  
   
       def checkDate(self,date):
           """teste ob zum Zeitpunkt date eine andere version existierte"""
                   
   
         if RESPONSE is not None:          def sortProjectsByTime(x,y):
             RESPONSE.redirect('showTree')              return cmp(x[1].archiveTime,y[1].archiveTime)
   
     def getProjectWithId(self,id):          #suche ob aeltere versionen vorhanden sind
         fields=self.getProjectFields('xdata_05')  
         for field in fields:  
             if field[1]==id:  
                 return field[0]  
   
         return None          finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
           if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
               ad=getattr(self,'creationTime','20050101000000')
               if int(date)>int(ad):
                   return self.REQUEST['URL1']+"/"+self.getId()
               else:
                   return self.REQUEST['URL1']+"/no_project"
                           
                   
           else:
               finds.sort(sortProjectsByTime)
                           
           for find in finds:
               #gehe durch die alten Projekte und finde das entprechende
               if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
                   return self.REQUEST['URL1']+"/"+find[1].getId()
                   
     def getRelativeUrlFromPerson(self,list):          #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
         """get urls to person list"""          ad=getattr(self,'creationTime','20050101000000')
         ret=[]  
         persons=list.split(";")  
         for person in persons:  
                           
             if len(person)>1: #nicht nur Trennzeichen          if int(date)>int(ad):
                 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=='':              return self.REQUEST['URL1']+"/"+self.getId()
           else:
               return self.REQUEST['URL1']+"/no_project"
   
                     try:  
                         proj=self.MembersCatalog({'title':search})  
                     except:  
                         proj=None  
   
                 if proj:      def no_project(self):
                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))          """warnung: project noch nicht existent"""
                     ret.append("<a href=%s >%s</a>"%('members/'+proj[0].id+'/index.html',person))          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)
                 else:          return pt()
                     #ret.append("%s"%person.encode('utf-8'))  
                     ret.append("%s"%person)  
         return string.join(ret,";")  
                   
                           
     def getUrlFromPerson(self,list):      def harvest_page(self,context=None):
         """get urls to person list"""          """seite fuer harvesting fuer die Projektsuche"""
         ret=[]          if not context:
         persons=list.split(";")              context=self
         for person in persons:  
                           
             if len(person)>1: #nicht nur Trennzeichen          if self.isActiveProject() and self.isActual():
                 splitted=person.split(",")               ext=getattr(self,"harvest_main",None)
                 if len(splitted)==1:               if ext:
                     splitted=person.lstrip().rstrip().split(" ")                   return getattr(self,ext.getId())()
                 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=='':               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)    
   
                     try:  
                         proj=self.MembersCatalog({'title':search})  
                     except:  
                         proj=None  
   
                 if proj:               return pt()
             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:  
                     #ret.append("%s"%person.encode('utf-8'))  
                     ret.append("%s"%person)  
         return string.join(ret,";")  
                                                     
     def getProjectsOfMembers(self):      def index_html(self,request=True,context=None):
         """give tuple member /projects"""          """show homepage"""
         ret=[]          if not context:
         members=self.getAllMembers()              context=self
         #return str(members)          if request:
         for x in members:              if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
             ret+=self.getProjectsOfMember(name=x)                  self.REQUEST.SESSION['MPI_redirected']=1
                   self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date'])+"?date="+self.REQUEST['date'])
               else:
                   self.REQUEST.SESSION['MPI_redirected']=None
                           
         return ret          #ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
           ext=getattr(self,"project_main",None)
           if ext:
               return getattr(self,ext.getId())()
   
     def getProjectsOfMember(self,name=None,email=None):          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)    
         """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)  
                   
           return pt()
                 
         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      def getDataFields(self):
         splitted=y.split(",")          """giveListofDatafields"""
         #XXXX          ret=[]
         splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]          for x in range(1,14):
               if not x in [6,10,9]: # not used fields
                   ret.append('xdata_%02i'%x)
           return ret
                   
         #for s in splitted:      def getDefinedFields(self):
         #    splitNeu.append("\""+s+"\"")          """show all defined fields"""
         search=string.join(splitNeu,' AND ')  
                   
         proj=self.ProjectCatalog({'xdata_01':search})          return definedFields
   
         if proj:      def getAttribute(self,field):
             proj2=[]          """get attrbiute"""
             for x in proj:          return getattr(self,field)
                             
                 if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):      def getContent(self,field,filter=None):
           """Inhalt des Feldes"""
                                                 
                        #print repr(splitted[1]),repr(splitted[0]),repr(x.WEB_title)          text=u''
                        proj2.append(x)  
         #    proj2.sort(sortP)  
         #    ret.append((y,proj2))  
         else:  
             proj2=[]  
                           
         proj=self.ProjectCatalog({'xdata_08':search})          for x in getattr(self,field):
         if proj:  
             names=[x.WEB_title for x in proj]  
             for x in proj:  
                 if not x.WEB_title in names:  
                     proj2.append(x)  
   
               try:
                   text +=x
               except:
                   text = x
   
         proj2.sort(sortP)  
   
         if len(proj2)>0:  
             ret.append((y,proj2))  
   
         return ret          try:
               if text[len(text)-1]==";":
                   text=text[0:len(text)-1]
             
     def givePersonList(self,name):  
         """check if person is in personfolder and return list of person objects"""  
                   
         splitted=name.split(",")          except:
         if len(splitted)==1:              pass
             splitted=name.lstrip().rstrip().split(" ")  
         splittedNew=[split.lstrip() for split in splitted]  
           
         if splittedNew[0]=='':  
             del splittedNew[0]  
         search=string.join(splittedNew,' AND ')  
         if not search=='':  
             proj=self.MembersCatalog({'title':search})  
   
         if proj:          if text=='':
             return [[x.lastName,x.firstName] for x in proj]              text2=text
         else:          else:
             return []              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')
                           
 ##         splitted=name.split(",") # version nachname, vorname...          if filter:
 ##         if len(splitted)>1:              splitted=text2.split("""<p class="picture">""")
 ##             lastName=splitted[0]               if len(splitted)>1:
 ##             firstName=splitted[1]                  tmp=splitted[1].split("</p>")
 ##         else:                   #return repr(splitted[1])
 ##             splitted=name.split(" ") #version vorname irgenwas nachnamae                  try:
                           self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
                   except:
                       try:
                           self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
                       except:
                           self.imageURL=""
                   
 ##             lastName=splitted[len(splitted)-1]                  split2="</p>".join(tmp[1:])
 ##             firstName=string.join(splitted[0:len(splitted)-1])  
   
 ##         objs=[]                  text3=splitted[0]+split2
   
         #print  self.members                   splitted=text3.split("""<p class="picturetitle">""")
       ##   for x in self.members.__dict__:                  if len(splitted)>1:
 ##             obj=getattr(self.members,x)                      tmp=splitted[1].split("</p>")
 ##             if hasattr(obj,'lastName') and hasattr(obj,'firstName'):                      self.imagecap=tmp[0].encode('utf-8')
                                   
 ##                 if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):                      split4="".join(tmp[1:])
                                           
 ##                     objs.append((obj,lastName+", "+firstName))                      text5=splitted[0]+split4
                   else:
                       #keine caption
                       text5=text3
               else:
                   #kein bild
                   text5=text2
           else:
               text5=text2
   
           #teste ob WEB_project_description und keine fuehrenden p tags
           if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
               text5= "<p>"+text5+"</p>"
                   
         return objs  
   
           #filter image
   
     def personCheck(self,names):          text5=text5.lstrip().rstrip() #loescher leerzeichen und einzelndes br
         """all persons for list"""          if (text5=="<br>") or (text5=="<br/>"):
         #print "names",names              text5=""
         splitted=names.split(";")  
         ret={}  
         for name in splitted:  
   
             if not (name==""):          #logging.debug("getcontent: field=%s filter=%s -> %s"%(field,filter,repr(text5)))
                 try:          return unicodify(text5)
                     ret[name]=self.givePersonList(name)          #return utf8ify(text5) # return as utf-8 byte string
                 except:  
                     """NOTHIHN"""  
         #print "RET",ret  
         return ret  
   
     def giveCheckList(self,person,fieldname):  
         """return checklist"""  
         #print "GCL",fieldname  
         if fieldname=='xdata_01':  
             x=self.personCheck(person.getContent(fieldname))  
             #print "GCLBACKX",x  
             return x  
                   
       def showImagesOfPage(self,imageUrl=None):
           """show Images of project"""
           self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
           return pt()
   
     def isCheckField(self,fieldname):  
         """return chechfield"""  
                   
         return (fieldname in checkFields)      def show_html(self):
           """simple index"""
           #return "HI"
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_index.zpt')).__of__(self)
           return pt()
   
       def saveFromPreview(self):
           """save content aus preview"""
           self.WEB_project_description=self.previewTemplate.WEB_project_description[0:]
           self.REQUEST.RESPONSE.redirect("./index.html")
   
       def saveEditedContent(self,kupu=None,preview=None):
           """save Edited content"""
           
           if preview:
               kupu=preview
           #find content of body tags
           start=kupu.find("<body>")
           end=kupu.find("</body>")
           newcontent= kupu[start+6:end]
           
           if preview:
                   
 def manage_addMPIWGRootForm(self):              return self.preview(newcontent)
     """form for adding the root"""  
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)  
     return pt()  
   
 def manage_addMPIWGRoot(self,id,title,RESPONSE=None):          self.copyObjectToArchive()
     """add a root folder"""          self.WEB_project_description=newcontent[0:]
     newObj=MPIWGRoot(id,title)  
     self._setObject(id,newObj)  
   
     if RESPONSE is not None:          self.REQUEST.RESPONSE.redirect("./index.html")
         RESPONSE.redirect('manage_main')  
                   
           return True
   
 class MPIWGProject(Folder):      security.declareProtected('View management screens','edit')
     """Class for Projects"""      def edit(self,western=None):
           """Edit pages"""
           if western:
               self.REQUEST.RESPONSE.setCookie("MP_debug_code","western",path="/")
   
     meta_type='MPIWGProject'  
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProjectNeu.zpt')).__of__(self)
           return pt()
         
     def crossLinker(self):      edit_MPIWGProject_main = PageTemplateFile('zpt/edit_MPIWGProject_main', globals())
         """experimental crosslinker"""  
         splitted=self.WEB_project_description[0].split()  
         new=[]  
         for split in splitted:  
             try:  
                 found=self.DescriptionCatalog({'fulltext':split})  
                       
                 if len(found)>1:      def getPathStyle(self, path, selected, style=""):
           """returns a string with the given style + 'sel' if path == selected."""
                             
                     new.append("<a href=%s>%s</a>"%(split,split))          if path == selected:
               return style + 'sel'
                 else:                  else:
                     new.append(split)              return style    
             except:  
                 new.append(split)      def getLabel(self):
         return string.join(new)          """returns label (or title) of this project"""
           l = self.getContent('xdata_07')
           if l:
               return l
           l = self.getContent('WEB_title')
           if l:
               return l
           return self.title
   
       def getBreadcrumbs(self):
           """return list of breadcrumbs from here to the root"""
           crumbs = []
           # skip direct parent Folder /projects/
           parent = self.aq_parent.aq_parent
           # get parents breadcrumbs
           if hasattr(parent, 'getBreadcrumbs'):
               crumbs = parent.getBreadcrumbs()
           
           # try to get acquisition URL from parent
           if hasattr(parent, 'absolute_url'):
               baseUrl = "%s/%s/"%(parent.absolute_url(), 'projects')
           else:
               baseUrl = "/en/research/projects/"
               
           # add in the internal project hierarchy
           ct=self.getContexts(parents=self.getContent('xdata_05'))
           # start with grandparents
           ct.reverse()
           for c in ct:
               label = shortenString(c[0].getLabel(), 13)
               crumbs.append((label, baseUrl+c[0].getId(), c[0]))            
   
           # add this project
           crumbs.append((self.getLabel(), baseUrl+self.getId(), self))
               
           return crumbs
   
       def getRootProject(self):
           """returns the root (=top level) project of the current project"""
           ct=self.getContexts(parents=self.getContent('xdata_05'))
           if len(ct) > 0:
               return ct[-1][0]
           else:
               return self        
   
   
       def preview(self,description):
           """preview"""
           tmpPro=getattr(self,"previewTemplate",None)
           if not tmpPro:
               tmpPro=MPIWGProject("previewTemplate")
               self._setObject("previewTemplate",tmpPro)
           for field in definedFields:
               setattr(tmpPro,field,getattr(self,field))
           tmpPro.WEB_project_description=description[0:]
           tmpPro.invisible=True
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','previewFrame.zpt')).__of__(self)
           return pt()
                           
           #return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"/previewTemplate")
                           
   
       def getWebProject_description(self):
           """get description"""
           debug= self.REQUEST.cookies.get("MP_debug_code",None)
           
           if debug and debug=="western":
               return """
               <html>
               <head>
               <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
               </head>
               <body>%s
               </html></body>
               """%self.WEB_project_description[0]
           
           return """
               <html>
               <head>
               <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
               </head>
               <body>%s
               </html></body>
               """%self.getContent('WEB_project_description')
   
     def generateTemplate(self,RESPONSE=None):  
         """Erzeuge Template für defined fields not_used"""  
   
         id="index_html"  
         title=id  
         if self._getOb('index_html'):  
             self._delObject('index_html')  
   
       def editMPIWGProjectForm(self):
           """editform"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)
           return pt()
   
       def isResponsibleScientist(self,key):
           """teste ob eine Person in der Liste der respl. scientists auftaucht"""
           #logging.info("XXXXXXXXXXXXX"+repr(self.responsibleScientistsList))
                   
         newObj=ZopePageTemplate(id,'TEXT')  
         self._setObject(id,newObj)  
         #self.manage_addPageTemplate(id,title)  
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
                           
     def __init__(self, id, argv=None):          keys = [unicodify(x[1]) for x in getattr(self,"responsibleScientistsList",[])]
         """initieriere classe"""          #logging.error("RESP. SCIEN:%s"%getattr(self,"responsibleScientistsList",[]))
           #logging.error("RESP. SCIEN:%s"%unicodify(key))
                   
         self.id=id          if unicodify(key) in keys:
         self.title=id              return True
         if argv:          else:
             for arg in definedFields:              return False
           
       def getPersonKeyList(self):
           """gibt die key Liste der beteiligten Personen zurŸck (utf8 codiert)"""
           #logging.error("getPersonKeyList:%s"%getattr(self,'responsibleScientistsList',[]))
         try:          try:
                     setattr(self,arg,argv[arg])              return [utf8ify(x[1]) for x in getattr(self,'responsibleScientistsList',[])]
         except:          except:
             setattr(self,arg,"")              return[]
           
          
       def myCapitalize(self,txt):
           """kapitalisiere auch Namen mit -"""
           splitted=[x.capitalize() for x in txt.split("-")]
           return "-".join(splitted)
       
       def getNamesOrdered(self,list):
           """Sortiert die Liste nach der Reihenfolge in xdata_01"""
           
           nameList=self.getContent('xdata_01')
           if nameList.find(";")>-1: # rate Trenner ist ;
               names=nameList.split(";")  
         else:          else:
             for arg in definedFields:              names=nameList.split(",")
                 setattr(self,arg,'')  
                           
     manage_options = Folder.manage_options+(              self._v_names=[]
         {'label':'Load New File','action':'loadNewFileForm'},              for name in names:
         {'label':'Edit ProjectInfo','action':'editMPIWGProjectForm'},                  self._v_names.append(name.rstrip().lstrip())
         {'label':'Edit BasisInfo','action':'editMPIWGBasisForm'},  
         {'label':'Edit Publications','action':'editMPIWGRelatedPublicationsForm'},  
         {'label':'Edit Themes & Disciplines','action':'editMPIWGDisciplinesThemesForm'},  
         )  
   
   
     def index_html(self):          def sort(x,y):
         """show homepage"""              try:
     ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])                  return cmp(self._v_names.index(x[0]),self._v_names.index(y[0]))
               except:
                   return 0
   
         if ext:          list.sort(sort)
             return getattr(self,ext[0][1].getId())()  
   
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/project_main').__of__(self)          return list
         return pt()  
   
           ##nameList=nameList.replace(";",",") # falls ; als Trenner ersetze    
           
     def getDataFields(self):  
         """giveListofDatafields"""  
         ret=[]  
         for x in range(1,14):  
             if not x in [6,10,9]: # not used fields  
                 ret.append('xdata_%02i'%x)  
         return ret  
                           
     def getDefinedFields(self):  
         """show all defined fields"""  
                   
         return definedFields  
   
     def getAttribute(self,field):      def identifyNames(self,nameList):
         """get attrbiute"""          """Bekommt eine Komma oder Semikolon getrennte Liste mit Name der Form Vorname MittelName(n) Nachname
         return getattr(self,field)          und ordnet diese dann Mitarbeiter IDs zu falls es schone eine Liste gibt wird im Projekte gibt wird diese Upgedated.
           @param nameList
           """
   
     def getContent(self,field):          if nameList.find(";")>-1: # rate Trenner ist ;
         """Inhalt des Feldes"""            names=nameList.split(";")  
                   
         text=u''          else:
         #print "FIELD",field              names=nameList.split(",")
         for x in getattr(self,field):  
             #print "HIHIIII"  
                           
             try:          ##nameList=nameList.replace(";",",") # falls ; als Trenner ersetze    
                 text +=x.encode('utf-8')          returnNamesDict={}
             except:  
                 try:  
                     text =x.encode('utf-8')  
                 except:  
                     text=x.decode('latin-1').encode('utf-8')  
                   
         #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]  
                       
           for name in names:
               name=name.lstrip().rstrip()
               nameSplitted = name.split(" ")
               if len(nameSplitted)>1:  #vor und nachname angegeben)
                                   
                   lastname=nameSplitted[-1]
                   firstname=nameSplitted[0]
               else:
                   firstname =""
                   lastname=nameSplitted[0]
                  
               #finde Mitarbeiter mit den entsprechenden Name
               
               firstname=self.myCapitalize(firstname).encode('utf-8')
               lastname=self.myCapitalize(lastname).encode('utf-8')
               logging.info("Search: %s %s %s"%(name,repr(firstname),repr(lastname)))
               try:
                   cataloggedNames=self.MembersCatalog({'firstName':firstname,'lastName':lastname})
         except:          except:
             """nothing"""                  cataloggedNames=[]
                   logging.error("ERROR: identifyNames %s %s"%sys.exc_info()[0:2])
   
         text2=re.sub(r';([^\s])','; \g<1>',text)              #Teste ob die ensprechenden Namen schon der Liste zu geordnet sind
         #teste ob ergebnis leer und header dann nehme title              #if not hasattr(self,'responsibleScientistsList'):
               #     self.responsibleScientistsList={}
               # 
               # if name in self.responsibleScientistsList.values()
                   
         if (text2=='') and (field=='WEB_project_header'):              if len(cataloggedNames)>0:
             return self.getContent('WEB_title')                 returnNamesDict[name]=cataloggedNames
               else:
                   returnNamesDict[name]=[]
   
         #teste ob WEB_project_description und keine führenden p tags          logging.error("id: %s"%repr(returnNamesDict))
         if (len(text2)>4) and (not text2[0:3]=='<p>') and (field=='WEB_project_description'):          return returnNamesDict
             return "<p>"+text2+"</p>"  
         #if text2=="Otto Sibum":  
         #text2="H. Otto Sibum"  
         return text2  
           
     def show_html(self):      def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
         """simple index"""          """edit the project and archive the old version"""
         #return "HI"  
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_index.zpt').__of__(self)  
         return pt()  
   
     def editMPIWGProjectForm(self):          self.copyObjectToArchive() # archive the object
         """editform"""  
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)  
         return pt()  
   
     def editMPIWGProject(self,RESPONSE=None):  
         """edit the project"""  
   
         #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')])
                           
           
          
   
           completedAt = self.REQUEST.get('completedAt')
           if not self.setCompletedAt(completedAt):
               RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
     
           startedAt = self.REQUEST.get('startedAt')
           if not self.setStartedAt(startedAt):
               RESPONSE.redirect('./editMPIWGBasisEditor?error="dateWrong')
           
           if self.REQUEST.has_key('historicalNames'):
               self.en.changeHistoricalNames(self.getId(),self.REQUEST['historicalNames'].split("\n"))
           
           if self.REQUEST.has_key('active'):
               self.setActiveFlag(True)
           else:
               self.setActiveFlag(False)
           
           self.responsibleScientistsList=[] # setze die Liste der verantwortlichen Wissenschaftler zurueck
           
           names={}
           keys={}
           tmpList=[]
           for key in self.REQUEST.keys(): #gehe durch das Formular
               splitted=key.split("_")
               if splitted[0]=="responsibleScientist": #wenn es ein Feld der Form reponsibleScientist_nr_KEY gibt
                   nr=splitted[2]
                   if splitted[1]=="name":
                       names[nr]=self.REQUEST[key]
                   elif splitted[1]=="key":
                       keys[nr]=self.REQUEST[key]
                   
            
           for nr in names.keys():#schreibe keys und namen in die Liste, stelle ausserdem sicher, dass name unicode
                tmpList.append((unicodify(names[nr]),unicodify(keys.get(nr,""))))
                
           self.responsibleScientistsList=tmpList
           if fromEdit and (RESPONSE is not None):
               #RESPONSE.redirect('./editMPIWGBasisEditor')
               return self.editMPIWGBasisEditor(identifiedNames=self.identifyNames(self.decode(self.REQUEST.get('xdata_01',''))))
               
           else:
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
   
       security.declareProtected('View managment screens','editMPIWGDisciplinesThemesEditor')
       def editMPIWGDisciplinesThemesEditor(self):
           """edit from edit"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemesNeu.zpt')).__of__(self)
           return pt()
           
       
     def editMPIWGDisciplinesThemesForm(self):      def editMPIWGDisciplinesThemesForm(self):
         """edit the disciplines and themes Form"""          """edit the disciplines and themes Form"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGDisciplinesThemes.zpt').__of__(self)       
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGDisciplinesThemes.zpt')).__of__(self)
         return pt()          return pt()
   
     def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None):      def editMPIWGDisciplinesThemes(self,disciplines=None,themes=None,RESPONSE=None,fromEdit=None):
         """edit disciplin and form"""          """edit disciplin and form"""
         if disciplines:          if disciplines:
             if type(disciplines) is StringType:              if type(disciplines) is StringType:
                 self.xdata_09=disciplines                  self.xdata_09=disciplines
             else:              else:
                 self.xdata_09=string.join(disciplines,";")                  self.xdata_09=";".join(disciplines)
         else:          else:
                 self.xdata_09=""                  self.xdata_09=""
         if themes:          if themes:
             if type(themes) is StringType:              if type(themes) is StringType:
                 self.xdata_10=themes                  self.xdata_10=themes
             else:              else:
                 self.xdata_10=string.join(themes,";")                  self.xdata_10=";".join(themes)
         else:          else:
             self.xdata_10=""              self.xdata_10=""
                           
           if fromEdit and (RESPONSE is not None):
               RESPONSE.redirect('./editMPIWGDisciplinesThemesEditor')
   
           else:
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def isChecked(self,wert,list):      def isChecked(self,wert,list):
         """check if wert is in ; seperated list"""          """check if wert is in ; seperated list"""
         print "W:",wert  
         print "L:",list,type(list)  
         #felder sind manchmnal als liste mit einem element definiert          #felder sind manchmnal als liste mit einem element definiert
         if type(list) is StringType or UnicodeType:           if type(list) is StringType or UnicodeType: 
             splitted=list.split(";")              splitted=list.split(";")
         else:          else:
             splitted=list[0].split(";")              splitted=list[0].split(";")
   
         print splitted          splitted=[y.rstrip().lstrip() for y in splitted]
           
         for x in splitted:          for x in splitted:
               x=re.sub(r"[^A-z ]","",x)
             if (not x==u'') and x in wert:              if (not x==u'') and x in wert:
                 return 1                  return 1
         return 0          return 0
           
       security.declareProtected('View management screens','editMPIWGBasisEditor')
       def editMPIWGBasisEditor(self, identifiedNames=None):
                               
           """editform"""
           if not identifiedNames:
               identifiedNames=self.identifyNames(self.getContent('xdata_01'))
              # identifiedNames=self.getFullNameEntries()
           
           logging.error("IdentifiedNames: %s"% repr(identifiedNames))
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasisNeu.zpt')).__of__(self)
           return pt(identifiedNames=identifiedNames)
   
       security.declareProtected('View management screens','editMPIWGBasisForm')
     def editMPIWGBasisForm(self):      def editMPIWGBasisForm(self):
         """editform"""          """editform"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGBasis.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGBasis.zpt')).__of__(self)
         return pt()          return pt()
   
       security.declareProtected('View management screens','editMPIWGRelatedPublicationsForm')
     def editMPIWGRelatedPublicationsForm(self):      def editMPIWGRelatedPublicationsForm(self):
         """Edit related Publications"""          """Edit related Publications"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGRelatedPublications.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGRelatedPublications.zpt')).__of__(self)
         return pt()          return pt()
                   
           
     def loadNewFileForm(self):      def loadNewFileForm(self):
         """Neues XML-File einlesen"""          """Neues XML-File einlesen"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_newfile.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_newfile.zpt')).__of__(self)
         return pt()          return pt()
   
     def loadNewFile(self,RESPONSE=None):      def loadNewFile(self,RESPONSE=None):
Line 1081  class MPIWGProject(Folder): Line 1294  class MPIWGProject(Folder):
   
 def manage_addMPIWGProjectForm(self):  def manage_addMPIWGProjectForm(self):
     """form for adding the project"""      """form for adding the project"""
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGProjectForm.zpt').__of__(self)      pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGProjectForm.zpt')).__of__(self)
     return pt()      return pt()
   
 def manage_addMPIWGProject(self,id,RESPONSE=None):  def manage_addMPIWGProject(self,id,RESPONSE=None):
Line 1089  def manage_addMPIWGProject(self,id,RESPO Line 1302  def manage_addMPIWGProject(self,id,RESPO
     #print argv      #print argv
     fileupload=self.REQUEST.get('fileupload',None)      fileupload=self.REQUEST.get('fileupload',None)
     if fileupload:      if fileupload:
         print fileupload  
         file_name=fileupload.filename          file_name=fileupload.filename
         filedata=fileupload.read()          filedata=fileupload.read()
                   
Removed from v.1.39  
changed lines
  Added in v.1.47.2.100

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