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

Diff for /MPIWGWeb/MPIWGProjects.py between versions 1.41 and 1.47.2.85

version 1.41, 2004/11/03 17:33:31 version 1.47.2.85, 2008/06/25 06:41:25
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
   s
 """  """
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
 from Products.PageTemplates.PageTemplate import PageTemplate  from Products.PageTemplates.PageTemplate import PageTemplate
 from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate  from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
 from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder  from Products.ZSQLExtend.ZSQLExtend import ZSQLExtendFolder
   from Products.ZCatalog.CatalogPathAwareness import CatalogAware
   from OFS.Image import Image
 from Globals import package_home  from Globals import package_home
 import urllib  import urllib
 import MPIWGStaff  import MPIWGStaff
Line 13  import string Line 15  import string
 import re  import re
 import os  import os
 from types import *  from types import *
 import zLOG  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 Products.ZSQLMethods.SQL import SQLConnectionIDs
   from AccessControl import ClassSecurityInfo
 from bibliography import *  from bibliography import *
   import time
   import xml.dom.minidom
   import sys
   from Ft.Xml.XPath import Evaluate
   from Ft.Xml.XPath.Context import Context
   from Ft.Xml.Domlette import NonvalidatingReader,PrettyPrint, Print
   from Ft.Xml import EMPTY_NAMESPACE
   import copy
   import updatePersonalWWW
   import MPIWGStaff
   
 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']  from MPIWGHelper import *
   
 checkFields = ['xdata_01']  import MPIWGRoot
   import MPIWGLink
   import MPIWGTemplate
   
   class MPIWGRoot(MPIWGRoot.MPIWGRoot):
       """depricated"""
   
   class MPIWGLink(MPIWGLink.MPIWGLink):
       """depricated"""
   
 def sortF(x,y):  class MPIWGTemplate(MPIWGTemplate.MPIWGTemplate):
     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 MPIWGProject_publication(SimpleItem):
     xsplit=x[1].split(".")      """publications object fuer project"""
     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:      meta_type="MPIWGProject_publication"
                 xret=xret+"%04i"%int(ysplit[i])  
             except:  
                 xret=xret+"%04i"%0  
                                   
       def editPublication(self,text=None,RESPONSE=None):
           """edit a publication"""
                   
         return cmp(int(yret),int(xret))          if (not text):
     except:              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_publicationForm.zpt')).__of__(self)
         return cmp(x[1],y[1])              return pt()
   
 class MPIWGTemplate(ZopePageTemplate):  
     """Create a layout Template for different purposes"""  
   
     meta_type="MPIWGTemplate"          self.text=text[0:]
   
     def __init__(self, id, text=None, content_type=None,MPIWGType=None):          if RESPONSE:
         self.id = str(id)              RESPONSE.redirect("../managePublications")
   
   class MPIWGProject_image(Image):
       """Images for Projects"""
   
       meta_type="MPIWGProject_image"
   
         self.ZBindings_edit(self._default_bindings)      def showImage(self,imageUrl=None):
         if text is None:          """show Images at an extra page"""
             self._default_content_fn = os.path.join(package_home(globals()),          self.getContent('WEB_project_description',filter='yes') #get the content and store image infos into session
                                                'zpt/MPIWG_%s_template_standard.zpt'%MPIWGType)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','projectImageView.zpt')).__of__(self)
             text = open(self._default_content_fn).read()          return pt()
         self.pt_edit(text, content_type)  
   
       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()
           
         """change form"""          if file and (not file.filename.lstrip().rstrip()==""):
               self.manage_upload(file)
   
           if caption:
               self.caption=caption[0:]
   
 def manage_addMPIWGTemplateForm(self):          if RESPONSE:
     """Form for adding"""              RESPONSE.redirect("../manageImages")
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt/AddMPIWGTemplate.zpt')).__of__(self)  
     return pt()  
   
 from urllib import quote  class MPIWGProject(CatalogAware,Folder):
       """Class for Projects"""
   
   
 def manage_addMPIWGTemplate(self, MPIWGType,id, title=None,REQUEST=None):      security=ClassSecurityInfo()
     "Add a Page Template with optional file content."      meta_type='MPIWGProject'
     if type(MPIWGType)==StringType:      default_catalog='ProjectCatalog'
         MPIWGTypes=[MPIWGType]  
     else:  
         MPIWGTypes=MPIWGType  
                   
     for singleType in MPIWGTypes:      def decode(self,str):
           """return unicode object"""
           return unicodify(str)
   
       def sortedByPlace(self,metatype):
           """find metatype and sort by place"""
           def sort(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
         if REQUEST is None:          founds=self.ZopeFind(self,obj_metatypes=[metatype]);
             self._setObject(id, MPIWGTemplate(id, text,EchoType=singleType))  
             ob = getattr(self, id)  
                           
             if title:          founds.sort(sort)
                 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)          return founds
             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"""  
   
     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'  
   
     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):      def copyPublicationsToList(self,RESPONSE=None):
         """patch"""          """copy publications in to list"""
         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 ""  
                   
           publicationTxt=self.getContent('WEB_related_pub')
   
     def redirectIndex_html(self,request):          pubSplits=publicationTxt.split("<p>")
         #return request['URL1']+'/index_html'  
                   
         return urllib.urlopen(request['URL1']+'/index_html').read()          for pubSplit in pubSplits:
               pubSplit=pubSplit.replace("</p>","")
               self.addPublication(pubSplit)
   
           if RESPONSE:
               RESPONSE.redirect('managePublications')
           
     def formatBibliography(self,here,found):  
         """format"""  
         return formatBibliography(here,found)  
           
     def getValue(self,fieldStr):      def copyImageToMargin(self,RESPONSE=None):  
         """Inhalt des Feldes"""          """copy inline images to marginal images"""
                   
         if type(fieldStr)==StringType:  
             field=fieldStr  
         else:  
             field=fieldStr[0]  
         try:  
             if field[len(field)-1]==";":  
                 field=field[0:len(field)-1]  
         except:  
   
             """nothing"""          #getImages from WEB_project_description
         field=re.sub(r';([^\s])','; \g<1>',field)          description=self.getContent('WEB_project_description')
         return field.encode('utf-8')  
   
           text2=description
           splitted=text2.split("""<p class="picture">""")
   
           imageURLs=[]
           imageCaptions=[]
           for split in  splitted[1:]:
                   tmp=split.split("</p>")
                   #return repr(splitted[1])
           
     def sortedNames(self,list):  
         """sort names"""  
   
         def sortLastName(x_c,y_c):  
             try:              try:
                 x=urllib.unquote(x_c).encode('utf-8','ignore')                          imageURLs.append(tmp[0].split("\"")[1].encode('utf-8'))
             except:              except:
                 x=urllib.unquote(x_c)  
   
             try:              try:
                 y=urllib.unquote(y_c).encode('utf-8','ignore')                          imageURLs.append(tmp[0].split("src=")[1].split(" ")[0].encode('utf-8'))
             except:              except:
                 x=urllib.unquote(y_c)                          imageURLs.append("")
                                   
                   split2="</p>".join(tmp[1:])
   
                           
             try:                  splitted=split2.split("""<p class="picturetitle">""")
                 last_x=x.split()[len(x.split())-1]                  if len(splitted)>1:
                 last_y=y.split()[len(y.split())-1]                      tmp=splitted[1].split("</p>")
                       imageCaptions.append(tmp[0].encode('utf-8'))
   
   
                   else:
                       #keine caption
   
                       imageCaptions.append("")
     
        
           #eintragen:
           for imageURL in imageURLs:
               filename=imageURL.split("/")[-1]
               #lege neues images object an, mit leerem bild
   
               if self.ZopeFind(self,obj_ids=[filename]):
                   #existiert das bild schon, dann neuen filenamen
                   filename="project_image_"+filename
               
               self.addImage(None,imageCaptions[imageURLs.index(imageURL)],filename=filename)
               #hole die bilddaten aus der url
               url=self.absolute_url()+"/"+imageURL
               #url=self.absolute_url()+"/"+filename
           
               try:#relative url
                   data=urllib.urlopen(url).read()
               except:
                   try:#absolute
                       data=urllib.urlopen(self.imageURL).read()
             except:              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"""  
             if (len(str)>1) and (str[0]==" "):  
                 ret=str[1:]  
             else:  
                 ret=str  
             return ret  
                   
         list={}          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_managePublicationsForm.zpt')).__of__(self)
         projects=self.ZopeFind(self.projects,obj_metatypes=['MPIWGProject'])          return pt()
                   
         for project in projects:      def getPublications(self):
             lg=len(project[1].xdata_03[0])-1          """get all Publications"""
           def sort_images(x,y):
               return cmp(getattr(x[1],'place',0),getattr(y[1],'place',0))
   
             if (lg>1) and (project[1].xdata_03[0][lg]==";"):          publications=self.ZopeFind(self,obj_metatypes=['MPIWGProject_publication'])
                 project[1].xdata_03[0]=project[1].xdata_03[0][0:lg]  
   
           publications.sort(sort_images)
           return publications
                       
       def addPublication(self,text,RESPONSE=None):
           """add an MPIWG_Publication"""
             
           name="publication_"+str(self.getLastPublicationNumber()+1)
                                   
             try:          newPublication=MPIWGProject_publication(name)
                 if len(project[1].xdata_03[0].split(";"))>1: # guess if separator is ;  
                     for person in project[1].xdata_03[0].split(";"):          self._setObject(name,newPublication)
                         personNormal=normalize(person)          obj=getattr(self,name)
                         if personNormal in list.keys():          obj.text=text[0:]
                             list[urllib.quote(personNormal)][1].append(project[1])          obj.enabled=True;
                         else:          obj.place=self.getLastPublicationNumber()+1
                             list[urllib.quote(personNormal)]=(personNormal,[project[1]])          obj.id=name
                 else: #guess , is sepeator          
                     for person in project[1].xdata_03[0].split(","):          if RESPONSE is not None:
                         personNormal=normalize(person)              RESPONSE.redirect('managePublications')
                         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 getLastPublicationNumber(self):
           publications=self.getPublications()
   
     def storeHistoricalPersons(self,RESPONSE=None):          if not publications:
         """store persons"""              return 0
         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:                  else:
                     self.personDict[person]=(personDict[person][0],[(project.absolute_url(),project.WEB_title[0],project.xdata_01[0])])              return getattr(publications[-1][1],'place',0)
   
         if RESPONSE is not None:      def deletePublication(self,id,RESPONSE=None):
             RESPONSE.redirect("showHistoricalPersons")              """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))
   
     def getPersonDict(self,name):  
         """name von dict"""  
   
           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):  
         """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):      def deleteImage(self,id,RESPONSE=None):
         """change"""          """delete Image id"""
         self.title=title          self.manage_delObjects([id])
         self.disciplineList=disciplineList          if RESPONSE:
         self.themesList=themesList              RESPONSE.redirect('manageImages')
   
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
   
     def getDisciplineList(self):      def hasChildren(self,date=None,onlyActive=1,onlyArchived=1):
         """get disciplines as list"""          """check if project has children"""
         return self.disciplineList.split("\n")          ct=self.getContexts(childs=self.getContent('xdata_05'),
                                        depth=1,date=date,onlyActive=onlyActive)
     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):          if ct and len(ct)>0:
         """childs alle childs, alle parents"""               return True
         ret=[]          else:
         if parents:               return False
             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:      def addImage(self,fileHd,caption,RESPONSE=None,filename=None):
             for project in self.getProjectFields('xdata_05',sort='int'):          """add an MPIWG_Project_image"""
                 searchStr=childs+"(\..*)"  
                 if re.match(searchStr,project[1]):  
                                           
                     if depth:          if not filename:
               filename=fileHd.filename
   
                         if int(depth)>=len(project[1].split("."))-len(childs.split(".")):          if not fileHd:
               fileHd=file(os.path.join(package_home(globals()),'blank.gif'))
                                           
                             ret.append(project)          newImage=MPIWGProject_image(filename,filename,fileHd)
                     else:  
                         ret.append(project)  
         return ret  
           
     def getProjectFields(self,fieldName,folder=None,sort=None):          self._setObject(filename,newImage)
         """getListofFieldNames"""          obj=getattr(self,filename)
         ret=[]          obj.caption=caption[0:]
           obj.enabled=True;
           obj.place=self.getLastImageNumber()+1
           obj.id=filename
           
         objects=self.ZopeFind(self,obj_metatypes=['MPIWGProject'],search_sub=1)          if RESPONSE is not None:
               RESPONSE.redirect('manageImages')
   
       def PrincipiaSearchSource(self):
           """Return cataloguable key for ourselves."""
           return str(self)
   
       def versionHeader(self):
           """version Header, gibt header text entsprechend der aktuellen version aus"""
           
           actualTime=time.localtime()
           retTXT="""<h2>This is an outdated version, for the actual version please refer to <a href="%s">%s</a></h2>"""
           s=self.aq_parent.absolute_url()
           #print getattr(self,'archiveTime',actualTime)
           if getattr(self,'archiveTime',actualTime)< actualTime:
               return retTXT%(s,s)
           else:
               return ""
                                   
         for object in objects:      def getActualVersion(self,date=None):
             obj=object[1]          """actuelle version"""
           def sortProjectsByTime(x,y):
               return cmp(x[1].archiveTime,y[1].archiveTime)
   
           if not date:
               if self.isActual():
                   return self
               else:
                   return None
   
             if not getattr(obj,'invisible',None):          #suche ob aeltere versionen vorhanden sind
                 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          finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
                         fieldNameTmp="WEB_title"          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:                      else:
                         fieldNameTmp="xdata_07"                  return None
   
   
                 else:                  else:
                     fieldNameTmp=fieldName              finds.sort(sortProjectsByTime)
   
                 ret.append((obj,obj.getContent(fieldNameTmp)))          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 sort=="int":          if int(date)>int(ad):
             ret.sort(sortI)  
         else:  
             ret.sort(sortF)  
                   
         return ret              return self
           else:
               return None
   
     def showNewProjects(self):  
         projects=[]  
         for objs in self.getProjectFields('WEB_title_or_short'): # Get all Projets  
             if objs[0].xdata_05[0] == "":  
                                   
                 projects.append(objs)      def isActual(self):
           """gibt 1 zurueck wenn aktuell, 0 sonst"""
           actualTime=time.localtime()
                                   
         return projects  
           
           #print getattr(self,'archiveTime',actualTime)
           if getattr(self,'archiveTime',actualTime)< actualTime:
               return 0
           else:
               return 1
                   
     manage_options = Folder.manage_options+(      def copyObjectToArchive(self):
         {'label':'Update Personal Homepages','action':'updateHomepages'},          """kopiere aktuelles objekt ins archiv"""
         {'label':'Main config','action':'changeMPIWGRootForm'},          cb=self.aq_parent.manage_copyObjects(self.getId())
         {'label':'Edit Historical Persons','action':'editHistoricalPersonsForm'},          self.manage_pasteObjects(cb)
         {'label':'Store Historical Persons','action':'storeHistoricalPersons'},          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 importNamesForm(self):      def versionManageForm(self):
         """Form"""          """version Manage form:currently only set to invisible"""
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGNamesForm.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)
         return pt()          return pt()
   
     def importNames(self,fileupload,folderName,RESPONSE=None):      def versionManage(self,invisible=None,RESPONSE=None):
         """import komma-sep list email,lastName,firstName"""          """version Manage form:currently only set to invisible"""
         project=getattr(self,folderName)          self.invisible=invisible
         load=fileupload.read()  
                   
         for line in load.split('\r'):          if RESPONSE is not None:
               RESPONSE.redirect('manage_main')
                           
                           
             splitted=line.split(",")      def crossLinker(self):
            # print splitted          """experimental crosslinker"""
           splitted=self.WEB_project_description[0].split()
           new=[]
           for split in splitted:
               try:
                   found=self.DescriptionCatalog({'fulltext':split})
                   
             if not (splitted[0]==""):                  if len(found)>1:
                 newObj=MPIWGStaff.MPIWGStaff(splitted[0],splitted[1],splitted[2])  
                                   
                 try:                      new.append("<a href=%s>%s</a>"%(split,split))
                     project._setObject(splitted[0],newObj)                  else:
                     #print "done:",splitted[0]                      new.append(split)
                 except:                  except:
                     print "not done:",splitted[0]                  new.append(split)
           return string.join(new)
               
               
   
   
       def generateTemplate(self,RESPONSE=None):
           """Erzeuge Template fuer defined fields not_used"""
   
           id="index_html"
           title=id
           if self._getOb('index_html'):
               self._delObject('index_html')
                                           
           
           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 getCompletedAt(self):
             #print x.title          """gibt das transformierte Datum zurŸck"""
         #    ret.append(x.title.decode('utf-8'))          date=getattr(self,'completedAt','')
           if date:
               return self.reTransformDate(date);
           else:
               return '';
   
         for x in self.ZopeFind(self.members,obj_metatypes=['MPIWGStaff']):      def reTransformDate(self,date):
                                ret.append(x[1].title.decode('utf-8'))          """transformiert , transformdate zurueck"""
           year=int(date/10000)
           month=int((date-year*10000)/100)
           day=int((date-year*10000-month*100))
           return """%s.%s.%s"""%(day,month,year);
                           
         ret.sort()  
         #print ret  
       
         return ret      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""" 
   
     def printAllMembers(self):          if (date=="" ) :
         """prin"""              return "";
         members=self.getAllMembers()  
         ret=""  
         for x in members:  
             ret+="<p>%s</p>"%x  
         return ret  
           
           if (date==None):
               return None;
                   
     def makeList(self,entry):          splitted=date.split(".")
         """makes a list out of one entry or repeat a list"""          length=len(splitted)
         if type(entry) is StringType:          year=0
             return [entry]          month=0
         else:          day=0
             return entry          if length > 3:
               return "";
           if length==3:
     def getTree(self):              day = int(splitted[0])
         """generate Tree from project list"""          if length>1:
         returnList=[]              month=int(splitted[length-2])
         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))  
   
           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)  
   
   
         if RESPONSE is not None:         ## logging.info("month:"+(month))
             RESPONSE.redirect('showTree')          if not (0<=month<13):
                       return None;
     def changeTree(self,RESPONSE=None):  
         """change the complete tree"""  
         form=self.REQUEST.form  
         hashList={}  
         fields=self.getTree()  
   
           if not(0<=day<32):
               return None;
                   
         for idNr in form.keys():          if (year>0) and (year<1900): #jahr nicht vierstellig eingegeben
             fields[int(idNr)][3].xdata_05=form[idNr]              year=2000+year;
           return year*10000+month*100+day
   
                   
   
         if RESPONSE is not None:      def checkDate(self,date):
             RESPONSE.redirect('showTree')          """teste ob zum Zeitpunkt date eine andere version existierte"""
   
     def getProjectWithId(self,id):  
         fields=self.getProjectFields('xdata_05')  
         for field in fields:  
             if field[1]==id:  
                 return field[0]  
   
         return None          def sortProjectsByTime(x,y):
               return cmp(x[1].archiveTime,y[1].archiveTime)
                           
           #suche ob aeltere versionen vorhanden sind
                   
           finds=self.ZopeFind(self,obj_metatypes=['MPIWGProject'])
           if not finds: #wenn nicht dann teste ob die aktuelle version schon existiert hat.
               ad=getattr(self,'creationTime','20050101000000')
               if int(date)>int(ad):
                   return self.REQUEST['URL1']+"/"+self.getId()
               else:
                   return self.REQUEST['URL1']+"/no_project"
                           
                   
     def getRelativeUrlFromPerson(self,list):          else:
         """get urls to person list"""              finds.sort(sortProjectsByTime)
         ret=[]  
         persons=list.split(";")  
         for person in persons:  
                           
             if len(person)>1: #nicht nur Trennzeichen          for find in finds:
                 splitted=person.split(",")              #gehe durch die alten Projekte und finde das entprechende
                 if len(splitted)==1:              if (int(find[1].archiveTime) > int(date)) and (int(date)>int(getattr(find[1],'creationTime','20050101000000'))):
                     splitted=person.split(" ")                  return self.REQUEST['URL1']+"/"+find[1].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=='':          #kein passendes gefunden, dann teste ob das aktuelle in frage kommt
           ad=getattr(self,'creationTime','20050101000000')
   
                     try:          if int(date)>int(ad):
                         proj=self.MembersCatalog({'title':search})  
                     except:  
                         proj=None  
   
                 if proj:              return self.REQUEST['URL1']+"/"+self.getId()
                     #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:                  else:
                     #ret.append("%s"%person.encode('utf-8'))              return self.REQUEST['URL1']+"/no_project"
                     ret.append("%s"%person)  
         return string.join(ret,";")  
                   
                           
     def getUrlFromPerson(self,list):      def no_project(self):
         """get urls to person list"""          """warnung: project noch nicht existent"""
         ret=[]          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','no_project')).__of__(self)
         persons=list.split(";")          return pt()
         for person in persons:  
                           
             if len(person)>1: #nicht nur Trennzeichen      def getGetNeighbourhood(self,wordStr, length=100,tagging=True):
                 splitted=person.split(",")          """finde umgebung um die worte in wordStr, zurueckgegeben wird eine Array mit den Umgebungen von Fundstellen der Worte
                 if len(splitted)==1:          alle Tags werden entfernt, die Fundstellen werden mit <span class="found">XX</span> getaggt, die Umgebungen werden 
                     splitted=person.lstrip().rstrip().split(" ")          case insensitive gesucht
                 splittedNew=[re.sub(r'\s(.*)','$1',split) for split in splitted]          @param wordStr: string mit Worten getrennt durch Leerzeichen, Phrasen sind mit " gekennzeichnet
                 if splittedNew[0]=='':                          "eine phrase", "*"  bezeichnet wildcards und wird ignoriert"
                     del splittedNew[0]          @param length: optional, default wert 100, 2*length ist die groesse der Umgebung
                 search=string.join(splittedNew,' AND ')          @param tagging: optional default wert true, kein span tag wird erzweugt falls tag=false
           """
                                   
                 if not search=='':          ret=[] # nimmt das Array auf, dass spaeter zurueckgegeben wird
           ranges=[] #Array mit tupeln x,y wobei x die Position des Anfang und y des Endes der i-ten Umgebung angiebt
   
                     try:          def isInRanges(nr,length):
                         proj=self.MembersCatalog({'title':search})              """test ob eine gegeben Position nr schon irgendwo in einer Umgebung ist, gibt den Index des ersten Wertes aus ranges zurueck, 
                     except:              -1, wenn kein Treffer
                         proj=None  
   
                 if proj:              @param nr: Position die geprueft werden soll
             if person =="Otto Sibum" : person="H. Otto Sibum"              @param length: Laenge des Wortes das geprueft werden soll
             if person =="Norton Wise" : person="M. Norton Wise"              """
                     #ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url,person.encode('utf-8')))              for x in ranges:
                     ret.append("<a href=%s >%s</a>"%(proj[0].absolute_url+"/index.html",person))                  if (x[0]<=nr) and (nr < (x[1]-length)):
                 else:                      return ranges.index(x)
                     #ret.append("%s"%person.encode('utf-8'))              return -1
                     ret.append("%s"%person)  
         return string.join(ret,";")  
                                                     
     def getProjectsOfMembers(self):          # deal with phrases, in Phrasen werden die Leerzeichen durch "_" ersetzt.
         """give tuple member /projects"""          def rep_empty(str):
         ret=[]              x= re.sub(" ","_",str.group(0))
         members=self.getAllMembers()              return re.sub("\"","",x)
         #return str(members)              
         for x in members:          wordStr=re.sub("\".*?\"", rep_empty,wordStr)#ersetze leerzeichen in " " durch "_" und loesche "
             ret+=self.getProjectsOfMember(name=x)          
           #deal with wildcards, for our purposes it is enough to delete the wildcard 
           wordStr=wordStr.replace("*","")
           
           words=wordStr.split(" ")
           #if not words is ListType:
           #   words=[words]
                           
           txt=self.harvest_page()
           if not txt:
         return ret          return ret
           txt=re.sub("<.*?>", "", txt) # loesche alle Tags
           for word in words:
               word=re.sub("_"," ",word) # ersetze zurueck "_" durch " "
               pos=0
   
     def getProjectsOfMember(self,name=None,email=None):              n=txt.lower().count(word.lower()) # wie oft tritt das Wort auf
         """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)  
                   
               for i in range(n):
                   pos=txt.lower().find(word.lower(),pos)
   
                   if pos > 0:
                       x=max(0,pos-length)
                       y=min(len(txt),pos+length)
                 
         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                      #is word already in one of the results
         splitted=y.split(",")                      nr=isInRanges(pos,len(word))
         #XXXX                      if nr >=0:# word ist in einer schon gefunden Umgebung, dann vergroessere diese
         splitNeu=["\'"+splitted[1]+" "+splitted[0]+"\'"]                          x=min(ranges[nr][0],x)
                           y=max(ranges[nr][1],y)
                   
         #for s in splitted:                      str=txt[x:y]
         #    splitNeu.append("\""+s+"\"")  
         search=string.join(splitNeu,' AND ')  
                   
         proj=self.ProjectCatalog({'xdata_01':search})                      if nr >=0: # word ist in einer schon gefunden Umgebung
                           ranges[nr]=(x,y) # neue Position der Umgebung
   
         if proj:                          ret[nr]=str # neue Umgebung
             proj2=[]                      else: # andernfalls neue Umgebung hinzufuegen
             for x in proj:                          ranges.append((x,y))
   
                 if not getattr(x.getObject(),'invisible',None):                          ret.append(str)
                     if not((splitted[1]==" Christoph") and (splitted[0]=="Hoffmann") and (str(x.WEB_title).find('Einstein')>0)):  
                        proj2.append(x)  
   
                       pos=pos+len(word)
         else:          else:
             proj2=[]                      break;
                           
         proj=self.ProjectCatalog({'xdata_08':search})          # now highlight everything        
         if proj:          if tagging:
             names=[x.WEB_title for x in proj]              for x in range(len(ret)):
             for x in proj:                  for word in words:
                       repl=re.compile(word,re.IGNORECASE)
                       ret[x]=repl.sub(""" <span class="found">%s</span>"""%word.upper(),ret[x])
   
                 if not x.WEB_title in names:          return ret
                     proj2.append(x)  
   
       def harvest_page(self,context=None):
           """seite fuer harvesting fuer die Projektsuche"""
           if not context:
               context=self
   
         proj2.sort(sortP)          if self.isActiveProject() and self.isActual():
                ext=getattr(self,"harvest_main",None)
                if ext:
                    return getattr(self,ext.getId())()
   
         if len(proj2)>0:               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','harvest_main')).__of__(context)    
             ret.append((y,proj2))  
   
         return ret  
             
     def givePersonList(self,name):               return pt()
         """check if person is in personfolder and return list of person objects"""  
                   
         splitted=name.split(",")      def index_html(self,request=True,context=None):
         if len(splitted)==1:          """show homepage"""
             splitted=name.lstrip().rstrip().split(" ")          if not context:
         splittedNew=[split.lstrip() for split in splitted]              context=self
           if request:
               if self.REQUEST.has_key('date') and self.REQUEST.SESSION.get('MPI_redirected',None)==None:
                   self.REQUEST.SESSION['MPI_redirected']=1
                   self.REQUEST.RESPONSE.redirect(self.checkDate(self.REQUEST['date'])+"?date="+self.REQUEST['date'])
               else:
                   self.REQUEST.SESSION['MPI_redirected']=None
                   
         if splittedNew[0]=='':          #ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])
             del splittedNew[0]          ext=getattr(self,"project_main",None)
         search=string.join(splittedNew,' AND ')          if ext:
         if not search=='':              return getattr(self,ext.getId())()
             proj=self.MembersCatalog({'title':search})  
   
         if proj:          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','project_main')).__of__(context)    
             return [[x.lastName,x.firstName] for x in proj]  
         else:  
             return []  
                           
 ##         splitted=name.split(",") # version nachname, vorname...          return pt()
 ##         if len(splitted)>1:  
 ##             lastName=splitted[0]   
 ##             firstName=splitted[1]  
 ##         else:   
 ##             splitted=name.split(" ") #version vorname irgenwas nachnamae  
                   
 ##             lastName=splitted[len(splitted)-1]  
 ##             firstName=string.join(splitted[0:len(splitted)-1])  
   
 ##         objs=[]      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
   
         #print  self.members       def getDefinedFields(self):
       ##   for x in self.members.__dict__:          """show all defined fields"""
 ##             obj=getattr(self.members,x)  
 ##             if hasattr(obj,'lastName') and hasattr(obj,'firstName'):  
                                   
 ##                 if (re.match(".*"+obj.lastName+".*",lastName) or re.match(".*"+lastName+".*",obj.lastName)) and (re.match(".*"+obj.firstName+".*",firstName) or re.match(".*"+firstName+".*",obj.firstName)):          return definedFields
                                           
 ##                     objs.append((obj,lastName+", "+firstName))      def getAttribute(self,field):
           """get attrbiute"""
           return getattr(self,field)
   
       def getContent(self,field,filter=None):
           """Inhalt des Feldes"""
                   
         return objs          text=u''
   
           for x in getattr(self,field):
               
               try:
                   text +=x
               except:
                   text = x
   
   
     def personCheck(self,names):  
         """all persons for list"""  
         #print "names",names  
         splitted=names.split(";")  
         ret={}  
         for name in splitted:  
   
             if not (name==""):  
                 try:                  try:
                     ret[name]=self.givePersonList(name)              if text[len(text)-1]==";":
                   text=text[0:len(text)-1]
             
                   
                 except:                  except:
                     """NOTHIHN"""              pass
         #print "RET",ret  
         return ret  
   
     def giveCheckList(self,person,fieldname):          if text=='':
         """return checklist"""              text2=text
         #print "GCL",fieldname          else:
         if fieldname=='xdata_01':              text2=re.sub(r';([^\s])','; \g<1>',text)
             x=self.personCheck(person.getContent(fieldname))  
             #print "GCLBACKX",x  
             return x  
                   
           #teste ob ergebnis leer und header dann nehme title
   
     def isCheckField(self,fieldname):          if (text2=='') and (field=='WEB_project_header'):
         """return chechfield"""              return self.getContent('WEB_title')
                   
         return (fieldname in checkFields)          if filter:
               splitted=text2.split("""<p class="picture">""")
               if len(splitted)>1:
                   tmp=splitted[1].split("</p>")
                   #return repr(splitted[1])
                   try:
                           self.imageURL=tmp[0].split("\"")[1].encode('utf-8')
                   except:
                       try:
                           self.imageURL=tmp[0].split("src=")[1].split(" ")[0].encode('utf-8')
                       except:
                           self.imageURL=""
   
                   split2="</p>".join(tmp[1:])
   
                   text3=splitted[0]+split2
           
                   splitted=text3.split("""<p class="picturetitle">""")
                   if len(splitted)>1:
                       tmp=splitted[1].split("</p>")
                       self.imagecap=tmp[0].encode('utf-8')
           
                       split4="".join(tmp[1:])
                   
 def manage_addMPIWGRootForm(self):                      text5=splitted[0]+split4
     """form for adding the root"""                  else:
     pt=PageTemplateFile('Products/MPIWGWeb/zpt/addMPIWGRootForm.zpt').__of__(self)                      #keine caption
     return pt()                      text5=text3
               else:
                   #kein bild
                   text5=text2
           else:
               text5=text2
   
 def manage_addMPIWGRoot(self,id,title,RESPONSE=None):          #teste ob WEB_project_description und keine fuehrenden p tags
     """add a root folder"""          if (len(text5)>4) and (not text5[0:3]=='<p>') and (field=='WEB_project_description'):
     newObj=MPIWGRoot(id,title)              text5= "<p>"+text5+"</p>"
     self._setObject(id,newObj)  
   
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
                   
           #filter image
   
 class MPIWGProject(Folder):          text5=text5.lstrip().rstrip() #loescher leerzeichen und einzelndes br
     """Class for Projects"""          if (text5=="<br>") or (text5=="<br/>"):
               text5=""
   
     meta_type='MPIWGProject'          logging.debug("getcontent: field=%s filter=%s -> %s"%(field,filter,repr(text5)))
           #return unicodify(text5)
           return utf8ify(text5) # return as utf-8 byte string
   
     def versionManageForm(self):  
         """version Manage form:currently only set to invisible"""      def showImagesOfPage(self,imageUrl=None):
         pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','MPIWGProject_versionManageForm.zpt')).__of__(self)          """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()          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:      def show_html(self):
             RESPONSE.redirect('manage_main')          """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 crossLinker(self):      def saveEditedContent(self,kupu=None,preview=None):
         """experimental crosslinker"""          """save Edited content"""
         splitted=self.WEB_project_description[0].split()  
         new=[]  
         for split in splitted:  
             try:  
                 found=self.DescriptionCatalog({'fulltext':split})  
                       
                 if len(found)>1:          if preview:
               kupu=preview
           #find content of body tags
           start=kupu.find("<body>")
           end=kupu.find("</body>")
           newcontent= kupu[start+6:end]
                             
                     new.append("<a href=%s>%s</a>"%(split,split))          if preview:
                 else:  
                     new.append(split)  
             except:  
                 new.append(split)  
         return string.join(new)  
                           
               return self.preview(newcontent)
                           
           self.copyObjectToArchive()
           self.WEB_project_description=newcontent[0:]
   
           self.REQUEST.RESPONSE.redirect("./index.html")
   
     def generateTemplate(self,RESPONSE=None):          return True
         """Erzeuge Template für defined fields not_used"""  
   
         id="index_html"      security.declareProtected('View management screens','edit')
         title=id      def edit(self,western=None):
         if self._getOb('index_html'):          """Edit pages"""
             self._delObject('index_html')          if western:
               self.REQUEST.RESPONSE.setCookie("MP_debug_code","western",path="/")
   
                   
         newObj=ZopePageTemplate(id,'TEXT')          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProjectNeu.zpt')).__of__(self)
         self._setObject(id,newObj)          return pt()
         #self.manage_addPageTemplate(id,title)  
         if RESPONSE is not None:  
             RESPONSE.redirect('manage_main')  
                           
     def __init__(self, id, argv=None):      edit_MPIWGProject_main = PageTemplateFile('zpt/edit_MPIWGProject_main', globals())
         """initieriere classe"""  
                   
         self.id=id      def getPathStyle(self, path, selected, style=""):
         self.title=id          """returns a string with the given style + 'sel' if path == selected."""
         if argv:  
             for arg in definedFields:          if path == selected:
         try:              return style + 'sel'
                     setattr(self,arg,argv[arg])  
         except:  
             setattr(self,arg,"")  
         else:          else:
             for arg in definedFields:              return style    
                 setattr(self,arg,'')  
       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()
                           
     manage_options = Folder.manage_options+(          #return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"/previewTemplate")
         {'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'},  
         )  
   
   
     def index_html(self):      def getWebProject_description(self):
         """show homepage"""          """get description"""
     ext=self.ZopeFind(self.aq_parent,obj_ids=["project_main"])          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')
           
   
         if ext:  
             return getattr(self,ext[0][1].getId())()  
   
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/project_main').__of__(self)      def editMPIWGProjectForm(self):
           """editform"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','edit_MPIWGProject.zpt')).__of__(self)
         return pt()          return pt()
   
       def isResponsibleScientist(self,key):
           """teste ob eine Person in der Liste der respl. scientists auftaucht"""
           #logging.info("XXXXXXXXXXXXX"+repr(self.responsibleScientistsList))
           
     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):          keys = [x[1] for x in getattr(self,"responsibleScientistsList",[])]
         """show all defined fields"""  
                   
         return definedFields          if key in keys:
               return True
           else:
               return False
   
     def getAttribute(self,field):      def getPersonKeyList(self):
         """get attrbiute"""          """gibt die key Lister der beteiligten Personen zurŸck"""
         return getattr(self,field)          return [x[1] for x in getattr(self,'responsibleScientistsList',[])]
   
     def getContent(self,field):  
         """Inhalt des Feldes"""  
                   
         text=u''  
         #print "FIELD",field  
         for x in getattr(self,field):  
             #print "HIHIIII"  
                           
             try:  
                 text +=x.encode('utf-8')  
             except:  
                 try:  
                     text =x.encode('utf-8')  
                 except:  
                     text=x.decode('latin-1').encode('utf-8')  
                   
         #delete separator (;) if  is there is one      def identifyNames(self,nameList):
         ## try:          """Bekommt eine Komma oder Semikolon getrennte Liste mit Name der Form Vorname MittelName(n) Nachname
 ##             print text, text[len(text)-1]          und ordnet diese dann Mitarbeiter IDs zu falls es schone eine Liste gibt wird im Projekte gibt wird diese Upgedated.
 ##         except:          @param nameList
 ##             print "error:",text          """
         try:          nameList=nameList.replace(";",",") # falls ; als Trenner ersetze
             if text[len(text)-1]==";":          names=nameList.split(",")
                 text=text[0:len(text)-1]  
                       
           returnNamesDict={}
                                   
         except:  
             """nothing"""  
   
         text2=re.sub(r';([^\s])','; \g<1>',text)          for name in names:
         #teste ob ergebnis leer und header dann nehme title              name=name.lstrip().rstrip()
               nameSplitted = name.split(" ")
               if len(nameSplitted)>1:  #vor und nachname angegeben)
                   
         if (text2=='') and (field=='WEB_project_header'):                  lastname=nameSplitted[-1]
             return self.getContent('WEB_title')                  firstname=nameSplitted[0]
               else:
                   firstname =""
                   lastname=nameSplitted[0]
   
         #teste ob WEB_project_description und keine führenden p tags              #finde Mitarbeiter mit den entsprechenden Name
         if (len(text2)>4) and (not text2[0:3]=='<p>') and (field=='WEB_project_description'):              logging.info("Search: %s %s %s"%(name,firstname,lastname))
             return "<p>"+text2+"</p>"              cataloggedNames=self.MembersCatalog(firstName=firstname,lastName=lastname)
         #if text2=="Otto Sibum":  
         #text2="H. Otto Sibum"  
         return text2  
           
     def show_html(self):              #Teste ob die ensprechenden Namen schon der Liste zu geordnet sind
         """simple index"""              #if not hasattr(self,'responsibleScientistsList'):
         #return "HI"              #     self.responsibleScientistsList={}
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/MPIWGProject_index.zpt').__of__(self)              # 
         return pt()              # if name in self.responsibleScientistsList.values()
   
     def editMPIWGProjectForm(self):              if len(cataloggedNames)>0:
         """editform"""                 returnNamesDict[name]=cataloggedNames
         pt=PageTemplateFile('Products/MPIWGWeb/zpt/edit_MPIWGProject.zpt').__of__(self)              else:
         return pt()                  returnNamesDict[name]=[]
          
           return returnNamesDict
           
       def editMPIWGProject(self,RESPONSE=None,fromEdit=None):
           """edit the project and archive the old version"""
           
           self.copyObjectToArchive() # archive the object
   
     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')
           
           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():
                tmpList.append((names[nr],keys.get(nr,"")))
                
           self.responsibleScientistsList=tmpList
           if fromEdit and (RESPONSE is not None):
               #RESPONSE.redirect('./editMPIWGBasisEditor')
               return self.editMPIWGBasisEditor(identifiedNames=self.identifyNames(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:
Line 1036  class MPIWGProject(Folder): Line 1126  class MPIWGProject(Folder):
         else:          else:
             self.xdata_10=""              self.xdata_10=""
                           
           if fromEdit and (RESPONSE is not None):
               RESPONSE.redirect('./editMPIWGDisciplinesThemesEditor')
   
           else:
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
   
     def isChecked(self,wert,list):      def isChecked(self,wert,list):
         """check if wert is in ; seperated list"""          """check if wert is in ; seperated list"""
         print "W:",wert  
         print "L:",list,type(list)  
         #felder sind manchmnal als liste mit einem element definiert          #felder sind manchmnal als liste mit einem element definiert
         if type(list) is StringType or UnicodeType:           if type(list) is StringType or UnicodeType: 
             splitted=list.split(";")              splitted=list.split(";")
         else:          else:
             splitted=list[0].split(";")              splitted=list[0].split(";")
   
         print splitted          splitted=[y.rstrip().lstrip() for y in splitted]
           
         for x in splitted:          for x in splitted:
               x=re.sub(r"[^A-z ]","",x)
             if (not x==u'') and x in wert:              if (not x==u'') and x in wert:
                 return 1                  return 1
         return 0          return 0
           
       security.declareProtected('View management screens','editMPIWGBasisEditor')
       def editMPIWGBasisEditor(self, identifiedNames=None):
                               
           """editform"""
           if not identifiedNames:
               identifiedNames=self.identifyNames(self.getContent('xdata_01'))
              # identifiedNames=self.getFullNameEntries()
               
           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 1096  class MPIWGProject(Folder): Line 1205  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 1104  def manage_addMPIWGProject(self,id,RESPO Line 1213  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.41  
changed lines
  Added in v.1.47.2.85

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